home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / mesa / src / eval_old.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-31  |  70.9 KB  |  2,452 lines
  1. /* $Id: eval.c,v 1.8 1997/07/24 01:25:01 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.4
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: eval.c,v $
  26.  * Revision 1.8  1997/07/24 01:25:01  brianp
  27.  * changed precompiled header symbol from PCH to PC_HEADER
  28.  *
  29.  * Revision 1.7  1997/06/20 01:58:47  brianp
  30.  * changed color components from GLfixed to GLubyte
  31.  *
  32.  * Revision 1.6  1997/05/28 03:24:22  brianp
  33.  * added precompiled header (PCH) support
  34.  *
  35.  * Revision 1.5  1997/05/14 03:27:04  brianp
  36.  * removed context argument from gl_init_eval()
  37.  *
  38.  * Revision 1.4  1997/05/01 01:38:38  brianp
  39.  * use NORMALIZE_3FV() from mmath.h instead of private NORMALIZE() macro
  40.  *
  41.  * Revision 1.3  1997/04/02 03:10:58  brianp
  42.  * changed some #include's
  43.  *
  44.  * Revision 1.2  1996/09/15 14:17:30  brianp
  45.  * now use GLframebuffer and GLvisual
  46.  *
  47.  * Revision 1.1  1996/09/13 01:38:16  brianp
  48.  * Initial revision
  49.  *
  50.  */
  51.  
  52.  
  53. /*
  54.  * eval.c was written by
  55.  * Bernd Barsuhn (bdbarsuh@cip.informatik.uni-erlangen.de) and
  56.  * Volker Weiss (vrweiss@cip.informatik.uni-erlangen.de).
  57.  *
  58.  * My original implementation of evaluators was simplistic and didn't
  59.  * compute surface normal vectors properly.  Bernd and Volker applied
  60.  * used more sophisticated methods to get better results.
  61.  *
  62.  * Thanks guys!
  63.  */
  64.  
  65.  
  66. #ifdef PC_HEADER
  67. #include "all.h"
  68. #else
  69. #include <math.h>
  70. #include <stdlib.h>
  71. #include <string.h>
  72. #include "context.h"
  73. #include "eval.h"
  74. #include "dlist.h"
  75. #include "macros.h"
  76. #include "mmath.h"
  77. #include "types.h"
  78. #include "vbfill.h"
  79. #endif
  80.  
  81.  
  82.  
  83. /*
  84.  * Do one-time initialization for evaluators.
  85.  */
  86. void gl_init_eval( void )
  87. {
  88.   static int init_flag = 0;
  89.  
  90.   /* Compute a table of nCr (combination) values used by the
  91.    * Bernstein polynomial generator.
  92.    */
  93.  
  94.   if (init_flag==0) 
  95.   { /* no initialization needed */ 
  96.   }
  97.  
  98.   init_flag = 1;
  99. }
  100.  
  101.  
  102.  
  103. /*
  104.  * Horner scheme for Bezier curves
  105.  * 
  106.  * Bezier curves can be computed via a Horner scheme.
  107.  * Horner is numerically less stable than the de Casteljau
  108.  * algorithm, but it is faster. For curves of degree n 
  109.  * the complexity of Horner is O(n) and de Casteljau is O(n^2).
  110.  * Since stability is not important for displaying curve 
  111.  * points I decided to use the Horner scheme.
  112.  *
  113.  * A cubic Bezier curve with control points b0, b1, b2, b3 can be 
  114.  * written as
  115.  *
  116.  *        (([3]        [3]     )     [3]       )     [3]
  117.  * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
  118.  *
  119.  *                                           [n]
  120.  * where s=1-t and the binomial coefficients [i]. These can 
  121.  * be computed iteratively using the identity:
  122.  *
  123.  * [n]               [n  ]             [n]
  124.  * [i] = (n-i+1)/i * [i-1]     and     [0] = 1
  125.  */
  126.  
  127. static void
  128. horner_bezier_curve(GLfloat *cp, GLfloat *out, GLfloat t,
  129.             GLuint dim, GLuint order)
  130. {
  131.   GLfloat s, powert;
  132.   GLuint i, k, bincoeff;
  133.  
  134.   if(order >= 2)
  135.   { 
  136.     bincoeff = order-1;
  137.     s = 1.0-t;
  138.  
  139.     for(k=0; k<dim; k++)
  140.       out[k] = s*cp[k] + bincoeff*t*cp[dim+k];
  141.  
  142.     for(i=2, cp+=2*dim, powert=t*t; i<order; i++, powert*=t, cp +=dim)
  143.     {
  144.       bincoeff *= order-i;
  145.       bincoeff /= i;
  146.  
  147.       for(k=0; k<dim; k++)
  148.     out[k] = s*out[k] + bincoeff*powert*cp[k];
  149.     }
  150.   }
  151.   else /* order=1 -> constant curve */
  152.   { 
  153.     for(k=0; k<dim; k++)
  154.       out[k] = cp[k];
  155.   } 
  156. }
  157.  
  158. /*
  159.  * Tensor product Bezier surfaces
  160.  *
  161.  * Again the Horner scheme is used to compute a point on a 
  162.  * TP Bezier surface. First a control polygon for a curve
  163.  * on the surface in one parameter direction is computed,
  164.  * then the point on the curve for the other parameter 
  165.  * direction is evaluated.
  166.  *
  167.  * To store the curve control polygon additional storage
  168.  * for max(uorder,vorder) points is needed in the 
  169.  * control net cn.
  170.  */
  171.  
  172. static void
  173. horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v,
  174.            GLuint dim, GLuint uorder, GLuint vorder)
  175. {
  176.   GLfloat *cp = cn + uorder*vorder*dim;
  177.   GLuint i, uinc = vorder*dim;
  178.  
  179.   if(vorder > uorder)
  180.   {
  181.     if(uorder >= 2)
  182.     { 
  183.       GLfloat s, poweru;
  184.       GLuint j, k, bincoeff;
  185.  
  186.       /* Compute the control polygon for the surface-curve in u-direction */
  187.       for(j=0; j<vorder; j++)
  188.       {
  189.     GLfloat *ucp = &cn[j*dim];
  190.  
  191.     /* Each control point is the point for parameter u on a */ 
  192.     /* curve defined by the control polygons in u-direction */
  193.     bincoeff = uorder-1;
  194.     s = 1.0-u;
  195.  
  196.     for(k=0; k<dim; k++)
  197.       cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
  198.  
  199.     for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder; 
  200.         i++, poweru*=u, ucp +=uinc)
  201.     {
  202.       bincoeff *= uorder-i;
  203.       bincoeff /= i;
  204.  
  205.       for(k=0; k<dim; k++)
  206.         cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
  207.     }
  208.       }
  209.     
  210.       /* Evaluate curve point in v */
  211.       horner_bezier_curve(cp, out, v, dim, vorder);
  212.     }
  213.     else /* uorder=1 -> cn defines a curve in v */
  214.       horner_bezier_curve(cn, out, v, dim, vorder);
  215.   }
  216.   else /* vorder <= uorder */
  217.   {
  218.     if(vorder > 1)
  219.     {
  220.       GLuint i;
  221.  
  222.       /* Compute the control polygon for the surface-curve in u-direction */
  223.       for(i=0; i<uorder; i++, cn += uinc)
  224.       {
  225.     /* For constant i all cn[i][j] (j=0..vorder) are located */
  226.     /* on consecutive memory locations, so we can use        */
  227.     /* horner_bezier_curve to compute the control points     */
  228.  
  229.     horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
  230.       }
  231.  
  232.       /* Evaluate curve point in u */
  233.       horner_bezier_curve(cp, out, u, dim, uorder);
  234.     }
  235.     else  /* vorder=1 -> cn defines a curve in u */
  236.       horner_bezier_curve(cn, out, u, dim, uorder);
  237.   }
  238. }
  239.  
  240. /*
  241.  * The direct de Casteljau algorithm is used when a point on the
  242.  * surface and the tangent directions spanning the tangent plane
  243.  * should be computed (this is needed to compute normals to the
  244.  * surface). In this case the de Casteljau algorithm approach is
  245.  * nicer because a point and the partial derivatives can be computed 
  246.  * at the same time. To get the correct tangent length du and dv
  247.  * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1. 
  248.  * Since only the directions are needed, this scaling step is omitted.
  249.  *
  250.  * De Casteljau needs additional storage for uorder*vorder
  251.  * values in the control net cn.
  252.  */
  253.  
  254. static void
  255. de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv,
  256.           GLfloat u, GLfloat v, GLuint dim, 
  257.           GLuint uorder, GLuint vorder)
  258. {
  259.   GLfloat *dcn = cn + uorder*vorder*dim;
  260.   GLfloat us = 1.0-u, vs = 1.0-v;
  261.   GLuint h, i, j, k;
  262.   GLuint minorder = uorder < vorder ? uorder : vorder;
  263.   GLuint uinc = vorder*dim;
  264.   GLuint dcuinc = vorder;
  265.  
  266.   /* Each component is evaluated separately to save buffer space  */
  267.   /* This does not drasticaly decrease the performance of the     */
  268.   /* algorithm. If additional storage for (uorder-1)*(vorder-1)   */
  269.   /* points would be available, the components could be accessed  */
  270.   /* in the innermost loop which could lead to less cache misses. */
  271.  
  272. #define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)] 
  273. #define DCN(I, J) dcn[(I)*dcuinc+(J)]
  274.   if(minorder < 3)
  275.   {
  276.     if(uorder==vorder)
  277.     {
  278.       for(k=0; k<dim; k++)
  279.       {
  280.     /* Derivative direction in u */
  281.     du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
  282.          v*(CN(1,1,k) - CN(0,1,k));
  283.  
  284.     /* Derivative direction in v */
  285.     dv[k] = us*(CN(0,1,k) - CN(0,0,k)) + 
  286.          u*(CN(1,1,k) - CN(1,0,k));
  287.  
  288.     /* bilinear de Casteljau step */
  289.     out[k] =  us*(vs*CN(0,0,k) + v*CN(0,1,k)) +
  290.            u*(vs*CN(1,0,k) + v*CN(1,1,k));
  291.       }
  292.     }
  293.     else if(minorder == uorder)
  294.     {
  295.       for(k=0; k<dim; k++)
  296.       {
  297.     /* bilinear de Casteljau step */
  298.     DCN(1,0) =    CN(1,0,k) -   CN(0,0,k);
  299.     DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
  300.  
  301.     for(j=0; j<vorder-1; j++)
  302.     {
  303.       /* for the derivative in u */
  304.       DCN(1,j+1) =    CN(1,j+1,k) -   CN(0,j+1,k);
  305.       DCN(1,j)   = vs*DCN(1,j)    + v*DCN(1,j+1);
  306.  
  307.       /* for the `point' */
  308.       DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
  309.       DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
  310.     }
  311.     
  312.     /* remaining linear de Casteljau steps until the second last step */
  313.     for(h=minorder; h<vorder-1; h++)
  314.       for(j=0; j<vorder-h; j++)
  315.       {
  316.         /* for the derivative in u */
  317.         DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
  318.  
  319.         /* for the `point' */
  320.         DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
  321.       }
  322.  
  323.     /* derivative direction in v */
  324.     dv[k] = DCN(0,1) - DCN(0,0);
  325.  
  326.     /* derivative direction in u */
  327.     du[k] =   vs*DCN(1,0) + v*DCN(1,1);
  328.  
  329.     /* last linear de Casteljau step */
  330.     out[k] =  vs*DCN(0,0) + v*DCN(0,1);
  331.       }
  332.     }
  333.     else /* minorder == vorder */
  334.     {
  335.       for(k=0; k<dim; k++)
  336.       {
  337.     /* bilinear de Casteljau step */
  338.     DCN(0,1) =    CN(0,1,k) -   CN(0,0,k);
  339.     DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
  340.     for(i=0; i<uorder-1; i++)
  341.     {
  342.       /* for the derivative in v */
  343.       DCN(i+1,1) =    CN(i+1,1,k) -   CN(i+1,0,k);
  344.       DCN(i,1)   = us*DCN(i,1)    + u*DCN(i+1,1);
  345.  
  346.       /* for the `point' */
  347.       DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
  348.       DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
  349.     }
  350.     
  351.     /* remaining linear de Casteljau steps until the second last step */
  352.     for(h=minorder; h<uorder-1; h++)
  353.       for(i=0; i<uorder-h; i++)
  354.       {
  355.         /* for the derivative in v */
  356.         DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
  357.  
  358.         /* for the `point' */
  359.         DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  360.       }
  361.  
  362.     /* derivative direction in u */
  363.     du[k] = DCN(1,0) - DCN(0,0);
  364.  
  365.     /* derivative direction in v */
  366.     dv[k] =   us*DCN(0,1) + u*DCN(1,1);
  367.  
  368.     /* last linear de Casteljau step */
  369.     out[k] =  us*DCN(0,0) + u*DCN(1,0);
  370.       }
  371.     }
  372.   }
  373.   else if(uorder == vorder)
  374.   {
  375.     for(k=0; k<dim; k++)
  376.     {
  377.       /* first bilinear de Casteljau step */
  378.       for(i=0; i<uorder-1; i++)
  379.       {
  380.     DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
  381.     for(j=0; j<vorder-1; j++)
  382.     {
  383.       DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
  384.       DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
  385.     }
  386.       }
  387.  
  388.       /* remaining bilinear de Casteljau steps until the second last step */
  389.       for(h=2; h<minorder-1; h++)
  390.     for(i=0; i<uorder-h; i++)
  391.     {
  392.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  393.       for(j=0; j<vorder-h; j++)
  394.       {
  395.         DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
  396.         DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
  397.       }
  398.     }
  399.  
  400.       /* derivative direction in u */
  401.       du[k] = vs*(DCN(1,0) - DCN(0,0)) +
  402.            v*(DCN(1,1) - DCN(0,1));
  403.  
  404.       /* derivative direction in v */
  405.       dv[k] = us*(DCN(0,1) - DCN(0,0)) + 
  406.            u*(DCN(1,1) - DCN(1,0));
  407.  
  408.       /* last bilinear de Casteljau step */
  409.       out[k] =  us*(vs*DCN(0,0) + v*DCN(0,1)) +
  410.          u*(vs*DCN(1,0) + v*DCN(1,1));
  411.     }
  412.   }
  413.   else if(minorder == uorder)
  414.   {
  415.     for(k=0; k<dim; k++)
  416.     {
  417.       /* first bilinear de Casteljau step */
  418.       for(i=0; i<uorder-1; i++)
  419.       {
  420.     DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
  421.     for(j=0; j<vorder-1; j++)
  422.     {
  423.       DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
  424.       DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
  425.     }
  426.       }
  427.  
  428.       /* remaining bilinear de Casteljau steps until the second last step */
  429.       for(h=2; h<minorder-1; h++)
  430.     for(i=0; i<uorder-h; i++)
  431.     {
  432.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  433.       for(j=0; j<vorder-h; j++)
  434.       {
  435.         DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
  436.         DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
  437.       }
  438.     }
  439.  
  440.       /* last bilinear de Casteljau step */
  441.       DCN(2,0) =    DCN(1,0) -   DCN(0,0);
  442.       DCN(0,0) = us*DCN(0,0) + u*DCN(1,0);
  443.       for(j=0; j<vorder-1; j++)
  444.       {
  445.     /* for the derivative in u */
  446.     DCN(2,j+1) =    DCN(1,j+1) -    DCN(0,j+1);
  447.     DCN(2,j)   = vs*DCN(2,j)    + v*DCN(2,j+1);
  448.     
  449.     /* for the `point' */
  450.     DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
  451.     DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
  452.       }
  453.     
  454.       /* remaining linear de Casteljau steps until the second last step */
  455.       for(h=minorder; h<vorder-1; h++)
  456.     for(j=0; j<vorder-h; j++)
  457.     {
  458.       /* for the derivative in u */
  459.       DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
  460.       
  461.       /* for the `point' */
  462.       DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
  463.     }
  464.       
  465.       /* derivative direction in v */
  466.       dv[k] = DCN(0,1) - DCN(0,0);
  467.       
  468.       /* derivative direction in u */
  469.       du[k] =   vs*DCN(2,0) + v*DCN(2,1);
  470.       
  471.       /* last linear de Casteljau step */
  472.       out[k] =  vs*DCN(0,0) + v*DCN(0,1);
  473.     }
  474.   }
  475.   else /* minorder == vorder */
  476.   {
  477.     for(k=0; k<dim; k++)
  478.     {
  479.       /* first bilinear de Casteljau step */
  480.       for(i=0; i<uorder-1; i++)
  481.       {
  482.     DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
  483.     for(j=0; j<vorder-1; j++)
  484.     {
  485.       DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
  486.       DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
  487.     }
  488.       }
  489.  
  490.       /* remaining bilinear de Casteljau steps until the second last step */
  491.       for(h=2; h<minorder-1; h++)
  492.     for(i=0; i<uorder-h; i++)
  493.     {
  494.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  495.       for(j=0; j<vorder-h; j++)
  496.       {
  497.         DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
  498.         DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
  499.       }
  500.     }
  501.  
  502.       /* last bilinear de Casteljau step */
  503.       DCN(0,2) =    DCN(0,1) -   DCN(0,0);
  504.       DCN(0,0) = vs*DCN(0,0) + v*DCN(0,1);
  505.       for(i=0; i<uorder-1; i++)
  506.       {
  507.     /* for the derivative in v */
  508.     DCN(i+1,2) =    DCN(i+1,1)  -   DCN(i+1,0);
  509.     DCN(i,2)   = us*DCN(i,2)    + u*DCN(i+1,2);
  510.     
  511.     /* for the `point' */
  512.     DCN(i+1,0) = vs*DCN(i+1,0)  + v*DCN(i+1,1);
  513.     DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
  514.       }
  515.       
  516.       /* remaining linear de Casteljau steps until the second last step */
  517.       for(h=minorder; h<uorder-1; h++)
  518.     for(i=0; i<uorder-h; i++)
  519.     {
  520.       /* for the derivative in v */
  521.       DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
  522.       
  523.       /* for the `point' */
  524.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  525.     }
  526.       
  527.       /* derivative direction in u */
  528.       du[k] = DCN(1,0) - DCN(0,0);
  529.       
  530.       /* derivative direction in v */
  531.       dv[k] =   us*DCN(0,2) + u*DCN(1,2);
  532.       
  533.       /* last linear de Casteljau step */
  534.       out[k] =  us*DCN(0,0) + u*DCN(1,0);
  535.     }
  536.   }
  537. #undef DCN
  538. #undef CN
  539. }
  540.  
  541. /*
  542.  * Return the number of components per control point for any type of
  543.  * evaluator.  Return 0 if bad target.
  544.  */
  545.  
  546. static GLint components( GLenum target )
  547. {
  548.    switch (target) {
  549.       case GL_MAP1_VERTEX_3:            return 3;
  550.       case GL_MAP1_VERTEX_4:            return 4;
  551.       case GL_MAP1_INDEX:               return 1;
  552.       case GL_MAP1_COLOR_4:             return 4;
  553.       case GL_MAP1_NORMAL:              return 3;
  554.       case GL_MAP1_TEXTURE_COORD_1:     return 1;
  555.       case GL_MAP1_TEXTURE_COORD_2:     return 2;
  556.       case GL_MAP1_TEXTURE_COORD_3:     return 3;
  557.       case GL_MAP1_TEXTURE_COORD_4:     return 4;
  558.       case GL_MAP2_VERTEX_3:            return 3;
  559.       case GL_MAP2_VERTEX_4:            return 4;
  560.       case GL_MAP2_INDEX:               return 1;
  561.       case GL_MAP2_COLOR_4:             return 4;
  562.       case GL_MAP2_NORMAL:              return 3;
  563.       case GL_MAP2_TEXTURE_COORD_1:     return 1;
  564.       case GL_MAP2_TEXTURE_COORD_2:     return 2;
  565.       case GL_MAP2_TEXTURE_COORD_3:     return 3;
  566.       case GL_MAP2_TEXTURE_COORD_4:     return 4;
  567.       default:                          return 0;
  568.    }
  569. }
  570.  
  571.  
  572. /**********************************************************************/
  573. /***            Copy and deallocate control points                  ***/
  574. /**********************************************************************/
  575.  
  576.  
  577. /*
  578.  * Copy 1-parametric evaluator control points from user-specified 
  579.  * memory space to a buffer of contiguous control points.
  580.  * Input:  see glMap1f for details
  581.  * Return:  pointer to buffer of contiguous control points or NULL if out
  582.  *          of memory.
  583.  */
  584. GLfloat *gl_copy_map_points1f( GLenum target,
  585.                    GLint ustride, GLint uorder,
  586.                    const GLfloat *points )
  587. {
  588.    GLfloat *buffer, *p;
  589.    GLuint i, k, size = components(target);
  590.  
  591.    if (!points || components==0) {
  592.       return NULL;
  593.    }
  594.  
  595.    buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
  596.  
  597.    if(buffer) 
  598.       for(i=0, p=buffer; i<uorder; i++, points+=ustride)
  599.     for(k=0; k<size; k++)
  600.       *p++ = points[k];
  601.  
  602.    return buffer;
  603. }
  604.  
  605.  
  606.  
  607. /*
  608.  * Same as above but convert doubles to floats.
  609.  */
  610. GLfloat *gl_copy_map_points1d( GLenum target,
  611.                 GLint ustride, GLint uorder,
  612.                 const GLdouble *points )
  613. {
  614.    GLfloat *buffer, *p;
  615.    GLuint i, k, size = components(target);
  616.  
  617.    buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
  618.  
  619.    if(buffer)
  620.       for(i=0, p=buffer; i<uorder; i++, points+=ustride)
  621.     for(k=0; k<size; k++)
  622.       *p++ = (GLfloat) points[k];
  623.  
  624.    return buffer;
  625. }
  626.  
  627.  
  628.  
  629. /*
  630.  * Copy 2-parametric evaluator control points from user-specified 
  631.  * memory space to a buffer of contiguous control points.
  632.  * Additional memory is allocated to be used by the horner and
  633.  * de Casteljau evaluation schemes.
  634.  *
  635.  * Input:  see glMap2f for details
  636.  * Return:  pointer to buffer of contiguous control points or NULL if out
  637.  *          of memory.
  638.  */
  639. GLfloat *gl_copy_map_points2f( GLenum target,
  640.                 GLint ustride, GLint uorder,
  641.                 GLint vstride, GLint vorder,
  642.                 const GLfloat *points )
  643. {
  644.    GLfloat *buffer, *p;
  645.    GLuint i, j, k, size, dsize, hsize;
  646.    GLint uinc;
  647.  
  648.    size = components(target);
  649.  
  650.    /* max(uorder, vorder) additional points are used in      */
  651.    /* horner evaluation and uorder*vorder additional */
  652.    /* values are needed for de Casteljau                     */
  653.    dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
  654.    hsize = (uorder > vorder ? uorder : vorder)*size;
  655.  
  656.    if(hsize>dsize)
  657.      buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
  658.    else
  659.      buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
  660.  
  661.    /* compute the increment value for the u-loop */
  662.    uinc = ustride - vorder*vstride;
  663.  
  664.    if (buffer) 
  665.       for (i=0, p=buffer; i<uorder; i++, points += uinc)
  666.      for (j=0; j<vorder; j++, points += vstride)
  667.         for (k=0; k<size; k++)
  668.            *p++ = points[k];
  669.  
  670.    return buffer;
  671. }
  672.  
  673.  
  674.  
  675. /*
  676.  * Same as above but convert doubles to floats.
  677.  */
  678. GLfloat *gl_copy_map_points2d(GLenum target,
  679.                   GLint ustride, GLint uorder,
  680.                   GLint vstride, GLint vorder,
  681.                   const GLdouble *points )
  682. {
  683.    GLfloat *buffer, *p;
  684.    GLuint i, j, k, size, hsize, dsize;
  685.    GLint uinc;
  686.  
  687.    size = components(target);
  688.  
  689.    /* max(uorder, vorder) additional points are used in      */
  690.    /* horner evaluation and uorder*vorder additional */
  691.    /* values are needed for de Casteljau                     */
  692.    dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
  693.    hsize = (uorder > vorder ? uorder : vorder)*size;
  694.  
  695.    if(hsize>dsize)
  696.      buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
  697.    else
  698.      buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
  699.  
  700.    /* compute the increment value for the u-loop */
  701.    uinc = ustride - vorder*vstride;
  702.  
  703.    if (buffer) 
  704.       for (i=0, p=buffer; i<uorder; i++, points += uinc)
  705.      for (j=0; j<vorder; j++, points += vstride)
  706.         for (k=0; k<size; k++)
  707.            *p++ = (GLfloat) points[k];
  708.  
  709.    return buffer;
  710. }
  711.  
  712.  
  713. /*
  714.  * This function is called by the display list deallocator function to
  715.  * specify that a given set of control points are no longer needed.
  716.  */
  717. void gl_free_control_points( GLcontext* ctx, GLenum target, GLfloat *data )
  718. {
  719.    struct gl_1d_map *map1 = NULL;
  720.    struct gl_2d_map *map2 = NULL;
  721.  
  722.    switch (target) {
  723.       case GL_MAP1_VERTEX_3:
  724.      map1 = &ctx->EvalMap.Map1Vertex3;
  725.      break;
  726.       case GL_MAP1_VERTEX_4:
  727.      map1 = &ctx->EvalMap.Map1Vertex4;
  728.      break;
  729.       case GL_MAP1_INDEX:
  730.      map1 = &ctx->EvalMap.Map1Index;
  731.      break;
  732.       case GL_MAP1_COLOR_4:
  733.      map1 = &ctx->EvalMap.Map1Color4;
  734.      break;
  735.       case GL_MAP1_NORMAL:
  736.      map1 = &ctx->EvalMap.Map1Normal;
  737.      break;
  738.       case GL_MAP1_TEXTURE_COORD_1:
  739.      map1 = &ctx->EvalMap.Map1Texture1;
  740.      break;
  741.       case GL_MAP1_TEXTURE_COORD_2:
  742.      map1 = &ctx->EvalMap.Map1Texture2;
  743.      break;
  744.       case GL_MAP1_TEXTURE_COORD_3:
  745.      map1 = &ctx->EvalMap.Map1Texture3;
  746.      break;
  747.       case GL_MAP1_TEXTURE_COORD_4:
  748.      map1 = &ctx->EvalMap.Map1Texture4;
  749.      break;
  750.       case GL_MAP2_VERTEX_3:
  751.      map2 = &ctx->EvalMap.Map2Vertex3;
  752.      break;
  753.       case GL_MAP2_VERTEX_4:
  754.      map2 = &ctx->EvalMap.Map2Vertex4;
  755.      break;
  756.       case GL_MAP2_INDEX:
  757.      map2 = &ctx->EvalMap.Map2Index;
  758.      break;
  759.       case GL_MAP2_COLOR_4:
  760.      map2 = &ctx->EvalMap.Map2Color4;
  761.      break;
  762.       case GL_MAP2_NORMAL:
  763.      map2 = &ctx->EvalMap.Map2Normal;
  764.      break;
  765.       case GL_MAP2_TEXTURE_COORD_1:
  766.      map2 = &ctx->EvalMap.Map2Texture1;
  767.      break;
  768.       case GL_MAP2_TEXTURE_COORD_2:
  769.      map2 = &ctx->EvalMap.Map2Texture2;
  770.      break;
  771.       case GL_MAP2_TEXTURE_COORD_3:
  772.      map2 = &ctx->EvalMap.Map2Texture3;
  773.      break;
  774.       case GL_MAP2_TEXTURE_COORD_4:
  775.      map2 = &ctx->EvalMap.Map2Texture4;
  776.      break;
  777.       default:
  778.      gl_error( ctx, GL_INVALID_ENUM, "gl_free_control_points" );
  779.      return;
  780.    }
  781.  
  782.    if (map1) {
  783.       if (data==map1->Points) {
  784.      /* The control points in the display list are currently */
  785.      /* being used so we can mark them as discard-able. */
  786.      map1->Retain = GL_FALSE;
  787.       }
  788.       else {
  789.      /* The control points in the display list are not currently */
  790.      /* being used. */
  791.      free( data );
  792.       }
  793.    }
  794.    if (map2) {
  795.       if (data==map2->Points) {
  796.      /* The control points in the display list are currently */
  797.      /* being used so we can mark them as discard-able. */
  798.      map2->Retain = GL_FALSE;
  799.       }
  800.       else {
  801.      /* The control points in the display list are not currently */
  802.      /* being used. */
  803.      free( data );
  804.       }
  805.    }
  806.  
  807. }
  808.  
  809.  
  810.  
  811. /**********************************************************************/
  812. /***                      API entry points                          ***/
  813. /**********************************************************************/
  814.  
  815.  
  816. /*
  817.  * Note that the array of control points must be 'unpacked' at this time.
  818.  * Input:  retain - if TRUE, this control point data is also in a display
  819.  *                  list and can't be freed until the list is freed.
  820.  */
  821. void gl_Map1f( GLcontext* ctx, GLenum target,
  822.            GLfloat u1, GLfloat u2, GLint stride,
  823.            GLint order, const GLfloat *points, GLboolean retain )
  824. {
  825.    GLuint k;
  826.  
  827.    if (!points) {
  828.       gl_error( ctx, GL_OUT_OF_MEMORY, "glMap1f" );
  829.       return;
  830.    }
  831.  
  832.    /* may be a new stride after copying control points */
  833.    stride = components( target );
  834.  
  835.    if (INSIDE_BEGIN_END(ctx)) {
  836.       gl_error( ctx, GL_INVALID_OPERATION, "glMap1" );
  837.       return;
  838.    }
  839.  
  840.    if (u1==u2) {
  841.       gl_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
  842.       return;
  843.    }
  844.  
  845.    if (order<1 || order>MAX_EVAL_ORDER) {
  846.       gl_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
  847.       return;
  848.    }
  849.  
  850.    k = components( target );
  851.    if (k==0) {
  852.       gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
  853.    }
  854.  
  855.    if (stride < k) {
  856.       gl_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
  857.       return;
  858.    }
  859.  
  860.    switch (target) {
  861.       case GL_MAP1_VERTEX_3:
  862.      ctx->EvalMap.Map1Vertex3.Order = order;
  863.      ctx->EvalMap.Map1Vertex3.u1 = u1;
  864.      ctx->EvalMap.Map1Vertex3.u2 = u2;
  865.      if (ctx->EvalMap.Map1Vertex3.Points
  866.          && !ctx->EvalMap.Map1Vertex3.Retain) {
  867.         free( ctx->EvalMap.Map1Vertex3.Points );
  868.      }
  869.      ctx->EvalMap.Map1Vertex3.Points = (GLfloat *) points;
  870.      ctx->EvalMap.Map1Vertex3.Retain = retain;
  871.      break;
  872.       case GL_MAP1_VERTEX_4:
  873.      ctx->EvalMap.Map1Vertex4.Order = order;
  874.      ctx->EvalMap.Map1Vertex4.u1 = u1;
  875.      ctx->EvalMap.Map1Vertex4.u2 = u2;
  876.      if (ctx->EvalMap.Map1Vertex4.Points
  877.          && !ctx->EvalMap.Map1Vertex4.Retain) {
  878.         free( ctx->EvalMap.Map1Vertex4.Points );
  879.      }
  880.      ctx->EvalMap.Map1Vertex4.Points = (GLfloat *) points;
  881.      ctx->EvalMap.Map1Vertex4.Retain = retain;
  882.      break;
  883.       case GL_MAP1_INDEX:
  884.      ctx->EvalMap.Map1Index.Order = order;
  885.      ctx->EvalMap.Map1Index.u1 = u1;
  886.      ctx->EvalMap.Map1Index.u2 = u2;
  887.      if (ctx->EvalMap.Map1Index.Points
  888.          && !ctx->EvalMap.Map1Index.Retain) {
  889.         free( ctx->EvalMap.Map1Index.Points );
  890.      }
  891.      ctx->EvalMap.Map1Index.Points = (GLfloat *) points;
  892.      ctx->EvalMap.Map1Index.Retain = retain;
  893.      break;
  894.       case GL_MAP1_COLOR_4:
  895.      ctx->EvalMap.Map1Color4.Order = order;
  896.      ctx->EvalMap.Map1Color4.u1 = u1;
  897.      ctx->EvalMap.Map1Color4.u2 = u2;
  898.      if (ctx->EvalMap.Map1Color4.Points
  899.          && !ctx->EvalMap.Map1Color4.Retain) {
  900.         free( ctx->EvalMap.Map1Color4.Points );
  901.      }
  902.      ctx->EvalMap.Map1Color4.Points = (GLfloat *) points;
  903.      ctx->EvalMap.Map1Color4.Retain = retain;
  904.      break;
  905.       case GL_MAP1_NORMAL:
  906.      ctx->EvalMap.Map1Normal.Order = order;
  907.      ctx->EvalMap.Map1Normal.u1 = u1;
  908.      ctx->EvalMap.Map1Normal.u2 = u2;
  909.      if (ctx->EvalMap.Map1Normal.Points
  910.          && !ctx->EvalMap.Map1Normal.Retain) {
  911.         free( ctx->EvalMap.Map1Normal.Points );
  912.      }
  913.      ctx->EvalMap.Map1Normal.Points = (GLfloat *) points;
  914.      ctx->EvalMap.Map1Normal.Retain = retain;
  915.      break;
  916.       case GL_MAP1_TEXTURE_COORD_1:
  917.      ctx->EvalMap.Map1Texture1.Order = order;
  918.      ctx->EvalMap.Map1Texture1.u1 = u1;
  919.      ctx->EvalMap.Map1Texture1.u2 = u2;
  920.      if (ctx->EvalMap.Map1Texture1.Points
  921.          && !ctx->EvalMap.Map1Texture1.Retain) {
  922.         free( ctx->EvalMap.Map1Texture1.Points );
  923.      }
  924.      ctx->EvalMap.Map1Texture1.Points = (GLfloat *) points;
  925.      ctx->EvalMap.Map1Texture1.Retain = retain;
  926.      break;
  927.       case GL_MAP1_TEXTURE_COORD_2:
  928.      ctx->EvalMap.Map1Texture2.Order = order;
  929.      ctx->EvalMap.Map1Texture2.u1 = u1;
  930.      ctx->EvalMap.Map1Texture2.u2 = u2;
  931.      if (ctx->EvalMap.Map1Texture2.Points
  932.          && !ctx->EvalMap.Map1Texture2.Retain) {
  933.         free( ctx->EvalMap.Map1Texture2.Points );
  934.      }
  935.      ctx->EvalMap.Map1Texture2.Points = (GLfloat *) points;
  936.      ctx->EvalMap.Map1Texture2.Retain = retain;
  937.      break;
  938.       case GL_MAP1_TEXTURE_COORD_3:
  939.      ctx->EvalMap.Map1Texture3.Order = order;
  940.      ctx->EvalMap.Map1Texture3.u1 = u1;
  941.      ctx->EvalMap.Map1Texture3.u2 = u2;
  942.      if (ctx->EvalMap.Map1Texture3.Points
  943.          && !ctx->EvalMap.Map1Texture3.Retain) {
  944.         free( ctx->EvalMap.Map1Texture3.Points );
  945.      }
  946.      ctx->EvalMap.Map1Texture3.Points = (GLfloat *) points;
  947.      ctx->EvalMap.Map1Texture3.Retain = retain;
  948.      break;
  949.       case GL_MAP1_TEXTURE_COORD_4:
  950.      ctx->EvalMap.Map1Texture4.Order = order;
  951.      ctx->EvalMap.Map1Texture4.u1 = u1;
  952.      ctx->EvalMap.Map1Texture4.u2 = u2;
  953.      if (ctx->EvalMap.Map1Texture4.Points
  954.          && !ctx->EvalMap.Map1Texture4.Retain) {
  955.         free( ctx->EvalMap.Map1Texture4.Points );
  956.      }
  957.      ctx->EvalMap.Map1Texture4.Points = (GLfloat *) points;
  958.      ctx->EvalMap.Map1Texture4.Retain = retain;
  959.      break;
  960.       default:
  961.      gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
  962.    }
  963. }
  964.  
  965.  
  966.  
  967.  
  968. /*
  969.  * Note that the array of control points must be 'unpacked' at this time.
  970.  * Input:  retain - if TRUE, this control point data is also in a display
  971.  *                  list and can't be freed until the list is freed.
  972.  */
  973. void gl_Map2f( GLcontext* ctx, GLenum target,
  974.           GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  975.           GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  976.           const GLfloat *points, GLboolean retain )
  977. {
  978.    GLuint k;
  979.  
  980.    if (INSIDE_BEGIN_END(ctx)) {
  981.       gl_error( ctx, GL_INVALID_OPERATION, "glMap2" );
  982.       return;
  983.    }
  984.  
  985.    if (u1==u2) {
  986.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
  987.       return;
  988.    }
  989.  
  990.    if (v1==v2) {
  991.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
  992.       return;
  993.    }
  994.  
  995.    if (uorder<1 || uorder>MAX_EVAL_ORDER) {
  996.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
  997.       return;
  998.    }
  999.  
  1000.    if (vorder<1 || vorder>MAX_EVAL_ORDER) {
  1001.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
  1002.       return;
  1003.    }
  1004.  
  1005.    k = components( target );
  1006.    if (k==0) {
  1007.       gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
  1008.    }
  1009.  
  1010.    if (ustride < k) {
  1011.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
  1012.       return;
  1013.    }
  1014.    if (vstride < k) {
  1015.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
  1016.       return;
  1017.    }
  1018.  
  1019.    switch (target) {
  1020.       case GL_MAP2_VERTEX_3:
  1021.      ctx->EvalMap.Map2Vertex3.Uorder = uorder;
  1022.      ctx->EvalMap.Map2Vertex3.u1 = u1;
  1023.      ctx->EvalMap.Map2Vertex3.u2 = u2;
  1024.      ctx->EvalMap.Map2Vertex3.Vorder = vorder;
  1025.      ctx->EvalMap.Map2Vertex3.v1 = v1;
  1026.      ctx->EvalMap.Map2Vertex3.v2 = v2;
  1027.      if (ctx->EvalMap.Map2Vertex3.Points
  1028.          && !ctx->EvalMap.Map2Vertex3.Retain) {
  1029.         free( ctx->EvalMap.Map2Vertex3.Points );
  1030.      }
  1031.      ctx->EvalMap.Map2Vertex3.Retain = retain;
  1032.      ctx->EvalMap.Map2Vertex3.Points = (GLfloat *) points;
  1033.      break;
  1034.       case GL_MAP2_VERTEX_4:
  1035.      ctx->EvalMap.Map2Vertex4.Uorder = uorder;
  1036.      ctx->EvalMap.Map2Vertex4.u1 = u1;
  1037.      ctx->EvalMap.Map2Vertex4.u2 = u2;
  1038.      ctx->EvalMap.Map2Vertex4.Vorder = vorder;
  1039.      ctx->EvalMap.Map2Vertex4.v1 = v1;
  1040.      ctx->EvalMap.Map2Vertex4.v2 = v2;
  1041.      if (ctx->EvalMap.Map2Vertex4.Points
  1042.          && !ctx->EvalMap.Map2Vertex4.Retain) {
  1043.         free( ctx->EvalMap.Map2Vertex4.Points );
  1044.      }
  1045.      ctx->EvalMap.Map2Vertex4.Points = (GLfloat *) points;
  1046.      ctx->EvalMap.Map2Vertex4.Retain = retain;
  1047.      break;
  1048.       case GL_MAP2_INDEX:
  1049.      ctx->EvalMap.Map2Index.Uorder = uorder;
  1050.      ctx->EvalMap.Map2Index.u1 = u1;
  1051.      ctx->EvalMap.Map2Index.u2 = u2;
  1052.      ctx->EvalMap.Map2Index.Vorder = vorder;
  1053.      ctx->EvalMap.Map2Index.v1 = v1;
  1054.      ctx->EvalMap.Map2Index.v2 = v2;
  1055.      if (ctx->EvalMap.Map2Index.Points
  1056.          && !ctx->EvalMap.Map2Index.Retain) {
  1057.         free( ctx->EvalMap.Map2Index.Points );
  1058.      }
  1059.      ctx->EvalMap.Map2Index.Retain = retain;
  1060.      ctx->EvalMap.Map2Index.Points = (GLfloat *) points;
  1061.      break;
  1062.       case GL_MAP2_COLOR_4:
  1063.      ctx->EvalMap.Map2Color4.Uorder = uorder;
  1064.      ctx->EvalMap.Map2Color4.u1 = u1;
  1065.      ctx->EvalMap.Map2Color4.u2 = u2;
  1066.      ctx->EvalMap.Map2Color4.Vorder = vorder;
  1067.      ctx->EvalMap.Map2Color4.v1 = v1;
  1068.      ctx->EvalMap.Map2Color4.v2 = v2;
  1069.      if (ctx->EvalMap.Map2Color4.Points
  1070.          && !ctx->EvalMap.Map2Color4.Retain) {
  1071.         free( ctx->EvalMap.Map2Color4.Points );
  1072.      }
  1073.      ctx->EvalMap.Map2Color4.Retain = retain;
  1074.      ctx->EvalMap.Map2Color4.Points = (GLfloat *) points;
  1075.      break;
  1076.       case GL_MAP2_NORMAL:
  1077.      ctx->EvalMap.Map2Normal.Uorder = uorder;
  1078.      ctx->EvalMap.Map2Normal.u1 = u1;
  1079.      ctx->EvalMap.Map2Normal.u2 = u2;
  1080.      ctx->EvalMap.Map2Normal.Vorder = vorder;
  1081.      ctx->EvalMap.Map2Normal.v1 = v1;
  1082.      ctx->EvalMap.Map2Normal.v2 = v2;
  1083.      if (ctx->EvalMap.Map2Normal.Points
  1084.          && !ctx->EvalMap.Map2Normal.Retain) {
  1085.         free( ctx->EvalMap.Map2Normal.Points );
  1086.      }
  1087.      ctx->EvalMap.Map2Normal.Retain = retain;
  1088.      ctx->EvalMap.Map2Normal.Points = (GLfloat *) points;
  1089.      break;
  1090.       case GL_MAP2_TEXTURE_COORD_1:
  1091.      ctx->EvalMap.Map2Texture1.Uorder = uorder;
  1092.      ctx->EvalMap.Map2Texture1.u1 = u1;
  1093.      ctx->EvalMap.Map2Texture1.u2 = u2;
  1094.      ctx->EvalMap.Map2Texture1.Vorder = vorder;
  1095.      ctx->EvalMap.Map2Texture1.v1 = v1;
  1096.      ctx->EvalMap.Map2Texture1.v2 = v2;
  1097.      if (ctx->EvalMap.Map2Texture1.Points
  1098.          && !ctx->EvalMap.Map2Texture1.Retain) {
  1099.         free( ctx->EvalMap.Map2Texture1.Points );
  1100.      }
  1101.      ctx->EvalMap.Map2Texture1.Retain = retain;
  1102.      ctx->EvalMap.Map2Texture1.Points = (GLfloat *) points;
  1103.      break;
  1104.       case GL_MAP2_TEXTURE_COORD_2:
  1105.      ctx->EvalMap.Map2Texture2.Uorder = uorder;
  1106.      ctx->EvalMap.Map2Texture2.u1 = u1;
  1107.      ctx->EvalMap.Map2Texture2.u2 = u2;
  1108.      ctx->EvalMap.Map2Texture2.Vorder = vorder;
  1109.      ctx->EvalMap.Map2Texture2.v1 = v1;
  1110.      ctx->EvalMap.Map2Texture2.v2 = v2;
  1111.      if (ctx->EvalMap.Map2Texture2.Points
  1112.          && !ctx->EvalMap.Map2Texture2.Retain) {
  1113.         free( ctx->EvalMap.Map2Texture2.Points );
  1114.      }
  1115.      ctx->EvalMap.Map2Texture2.Retain = retain;
  1116.      ctx->EvalMap.Map2Texture2.Points = (GLfloat *) points;
  1117.      break;
  1118.       case GL_MAP2_TEXTURE_COORD_3:
  1119.      ctx->EvalMap.Map2Texture3.Uorder = uorder;
  1120.      ctx->EvalMap.Map2Texture3.u1 = u1;
  1121.      ctx->EvalMap.Map2Texture3.u2 = u2;
  1122.      ctx->EvalMap.Map2Texture3.Vorder = vorder;
  1123.      ctx->EvalMap.Map2Texture3.v1 = v1;
  1124.      ctx->EvalMap.Map2Texture3.v2 = v2;
  1125.      if (ctx->EvalMap.Map2Texture3.Points
  1126.          && !ctx->EvalMap.Map2Texture3.Retain) {
  1127.         free( ctx->EvalMap.Map2Texture3.Points );
  1128.      }
  1129.      ctx->EvalMap.Map2Texture3.Retain = retain;
  1130.      ctx->EvalMap.Map2Texture3.Points = (GLfloat *) points;
  1131.      break;
  1132.       case GL_MAP2_TEXTURE_COORD_4:
  1133.      ctx->EvalMap.Map2Texture4.Uorder = uorder;
  1134.      ctx->EvalMap.Map2Texture4.u1 = u1;
  1135.      ctx->EvalMap.Map2Texture4.u2 = u2;
  1136.      ctx->EvalMap.Map2Texture4.Vorder = vorder;
  1137.      ctx->EvalMap.Map2Texture4.v1 = v1;
  1138.      ctx->EvalMap.Map2Texture4.v2 = v2;
  1139.      if (ctx->EvalMap.Map2Texture4.Points
  1140.          && !ctx->EvalMap.Map2Texture4.Retain) {
  1141.         free( ctx->EvalMap.Map2Texture4.Points );
  1142.      }
  1143.      ctx->EvalMap.Map2Texture4.Retain = retain;
  1144.      ctx->EvalMap.Map2Texture4.Points = (GLfloat *) points;
  1145.      break;
  1146.       default:
  1147.      gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
  1148.    }
  1149. }
  1150.  
  1151.  
  1152.    
  1153.  
  1154.  
  1155. void gl_GetMapdv( GLcontext* ctx, GLenum target, GLenum query, GLdouble *v )
  1156. {
  1157.    GLuint i, n;
  1158.    GLfloat *data;
  1159.  
  1160.    switch (query) {
  1161.       case GL_COEFF:
  1162.      switch (target) {
  1163.         case GL_MAP1_COLOR_4:
  1164.            data = ctx->EvalMap.Map1Color4.Points;
  1165.            n = ctx->EvalMap.Map1Color4.Order * 4;
  1166.            break;
  1167.         case GL_MAP1_INDEX:
  1168.            data = ctx->EvalMap.Map1Index.Points;
  1169.            n = ctx->EvalMap.Map1Index.Order;
  1170.            break;
  1171.         case GL_MAP1_NORMAL:
  1172.            data = ctx->EvalMap.Map1Normal.Points;
  1173.            n = ctx->EvalMap.Map1Normal.Order * 3;
  1174.            break;
  1175.         case GL_MAP1_TEXTURE_COORD_1:
  1176.            data = ctx->EvalMap.Map1Texture1.Points;
  1177.            n = ctx->EvalMap.Map1Texture1.Order * 1;
  1178.            break;
  1179.         case GL_MAP1_TEXTURE_COORD_2:
  1180.            data = ctx->EvalMap.Map1Texture2.Points;
  1181.            n = ctx->EvalMap.Map1Texture2.Order * 2;
  1182.            break;
  1183.         case GL_MAP1_TEXTURE_COORD_3:
  1184.            data = ctx->EvalMap.Map1Texture3.Points;
  1185.            n = ctx->EvalMap.Map1Texture3.Order * 3;
  1186.            break;
  1187.         case GL_MAP1_TEXTURE_COORD_4:
  1188.            data = ctx->EvalMap.Map1Texture4.Points;
  1189.            n = ctx->EvalMap.Map1Texture4.Order * 4;
  1190.            break;
  1191.         case GL_MAP1_VERTEX_3:
  1192.            data = ctx->EvalMap.Map1Vertex3.Points;
  1193.            n = ctx->EvalMap.Map1Vertex3.Order * 3;
  1194.            break;
  1195.         case GL_MAP1_VERTEX_4:
  1196.            data = ctx->EvalMap.Map1Vertex4.Points;
  1197.            n = ctx->EvalMap.Map1Vertex4.Order * 4;
  1198.            break;
  1199.         case GL_MAP2_COLOR_4:
  1200.            data = ctx->EvalMap.Map2Color4.Points;
  1201.            n = ctx->EvalMap.Map2Color4.Uorder
  1202.          * ctx->EvalMap.Map2Color4.Vorder * 4;
  1203.            break;
  1204.         case GL_MAP2_INDEX:
  1205.            data = ctx->EvalMap.Map2Index.Points;
  1206.            n = ctx->EvalMap.Map2Index.Uorder
  1207.          * ctx->EvalMap.Map2Index.Vorder;
  1208.            break;
  1209.         case GL_MAP2_NORMAL:
  1210.            data = ctx->EvalMap.Map2Normal.Points;
  1211.            n = ctx->EvalMap.Map2Normal.Uorder
  1212.          * ctx->EvalMap.Map2Normal.Vorder * 3;
  1213.            break;
  1214.         case GL_MAP2_TEXTURE_COORD_1:
  1215.            data = ctx->EvalMap.Map2Texture1.Points;
  1216.            n = ctx->EvalMap.Map2Texture1.Uorder
  1217.          * ctx->EvalMap.Map2Texture1.Vorder * 1;
  1218.            break;
  1219.         case GL_MAP2_TEXTURE_COORD_2:
  1220.            data = ctx->EvalMap.Map2Texture2.Points;
  1221.            n = ctx->EvalMap.Map2Texture2.Uorder
  1222.          * ctx->EvalMap.Map2Texture2.Vorder * 2;
  1223.            break;
  1224.         case GL_MAP2_TEXTURE_COORD_3:
  1225.            data = ctx->EvalMap.Map2Texture3.Points;
  1226.            n = ctx->EvalMap.Map2Texture3.Uorder
  1227.          * ctx->EvalMap.Map2Texture3.Vorder * 3;
  1228.            break;
  1229.         case GL_MAP2_TEXTURE_COORD_4:
  1230.            data = ctx->EvalMap.Map2Texture4.Points;
  1231.            n = ctx->EvalMap.Map2Texture4.Uorder
  1232.          * ctx->EvalMap.Map2Texture4.Vorder * 4;
  1233.            break;
  1234.         case GL_MAP2_VERTEX_3:
  1235.            data = ctx->EvalMap.Map2Vertex3.Points;
  1236.            n = ctx->EvalMap.Map2Vertex3.Uorder
  1237.          * ctx->EvalMap.Map2Vertex3.Vorder * 3;
  1238.            break;
  1239.         case GL_MAP2_VERTEX_4:
  1240.            data = ctx->EvalMap.Map2Vertex4.Points;
  1241.            n = ctx->EvalMap.Map2Vertex4.Uorder
  1242.          * ctx->EvalMap.Map2Vertex4.Vorder * 4;
  1243.            break;
  1244.         default:
  1245.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
  1246.      }
  1247.      if (data) {
  1248.         for (i=0;i<n;i++) {
  1249.            v[i] = data[i];
  1250.         }
  1251.      }
  1252.      break;
  1253.       case GL_ORDER:
  1254.      switch (target) {
  1255.         case GL_MAP1_COLOR_4:
  1256.            *v = ctx->EvalMap.Map1Color4.Order;
  1257.            break;
  1258.         case GL_MAP1_INDEX:
  1259.            *v = ctx->EvalMap.Map1Index.Order;
  1260.            break;
  1261.         case GL_MAP1_NORMAL:
  1262.            *v = ctx->EvalMap.Map1Normal.Order;
  1263.            break;
  1264.         case GL_MAP1_TEXTURE_COORD_1:
  1265.            *v = ctx->EvalMap.Map1Texture1.Order;
  1266.            break;
  1267.         case GL_MAP1_TEXTURE_COORD_2:
  1268.            *v = ctx->EvalMap.Map1Texture2.Order;
  1269.            break;
  1270.         case GL_MAP1_TEXTURE_COORD_3:
  1271.            *v = ctx->EvalMap.Map1Texture3.Order;
  1272.            break;
  1273.         case GL_MAP1_TEXTURE_COORD_4:
  1274.            *v = ctx->EvalMap.Map1Texture4.Order;
  1275.            break;
  1276.         case GL_MAP1_VERTEX_3:
  1277.            *v = ctx->EvalMap.Map1Vertex3.Order;
  1278.            break;
  1279.         case GL_MAP1_VERTEX_4:
  1280.            *v = ctx->EvalMap.Map1Vertex4.Order;
  1281.            break;
  1282.         case GL_MAP2_COLOR_4:
  1283.            v[0] = ctx->EvalMap.Map2Color4.Uorder;
  1284.            v[1] = ctx->EvalMap.Map2Color4.Vorder;
  1285.            break;
  1286.         case GL_MAP2_INDEX:
  1287.            v[0] = ctx->EvalMap.Map2Index.Uorder;
  1288.            v[1] = ctx->EvalMap.Map2Index.Vorder;
  1289.            break;
  1290.         case GL_MAP2_NORMAL:
  1291.            v[0] = ctx->EvalMap.Map2Normal.Uorder;
  1292.            v[1] = ctx->EvalMap.Map2Normal.Vorder;
  1293.            break;
  1294.         case GL_MAP2_TEXTURE_COORD_1:
  1295.            v[0] = ctx->EvalMap.Map2Texture1.Uorder;
  1296.            v[1] = ctx->EvalMap.Map2Texture1.Vorder;
  1297.            break;
  1298.         case GL_MAP2_TEXTURE_COORD_2:
  1299.            v[0] = ctx->EvalMap.Map2Texture2.Uorder;
  1300.            v[1] = ctx->EvalMap.Map2Texture2.Vorder;
  1301.            break;
  1302.         case GL_MAP2_TEXTURE_COORD_3:
  1303.            v[0] = ctx->EvalMap.Map2Texture3.Uorder;
  1304.            v[1] = ctx->EvalMap.Map2Texture3.Vorder;
  1305.            break;
  1306.         case GL_MAP2_TEXTURE_COORD_4:
  1307.            v[0] = ctx->EvalMap.Map2Texture4.Uorder;
  1308.            v[1] = ctx->EvalMap.Map2Texture4.Vorder;
  1309.            break;
  1310.         case GL_MAP2_VERTEX_3:
  1311.            v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
  1312.            v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
  1313.            break;
  1314.         case GL_MAP2_VERTEX_4:
  1315.            v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
  1316.            v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
  1317.            break;
  1318.         default:
  1319.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
  1320.      }
  1321.      break;
  1322.       case GL_DOMAIN:
  1323.      switch (target) {
  1324.         case GL_MAP1_COLOR_4:
  1325.            v[0] = ctx->EvalMap.Map1Color4.u1;
  1326.            v[1] = ctx->EvalMap.Map1Color4.u2;
  1327.            break;
  1328.         case GL_MAP1_INDEX:
  1329.            v[0] = ctx->EvalMap.Map1Index.u1;
  1330.            v[1] = ctx->EvalMap.Map1Index.u2;
  1331.            break;
  1332.         case GL_MAP1_NORMAL:
  1333.            v[0] = ctx->EvalMap.Map1Normal.u1;
  1334.            v[1] = ctx->EvalMap.Map1Normal.u2;
  1335.            break;
  1336.         case GL_MAP1_TEXTURE_COORD_1:
  1337.            v[0] = ctx->EvalMap.Map1Texture1.u1;
  1338.            v[1] = ctx->EvalMap.Map1Texture1.u2;
  1339.            break;
  1340.         case GL_MAP1_TEXTURE_COORD_2:
  1341.            v[0] = ctx->EvalMap.Map1Texture2.u1;
  1342.            v[1] = ctx->EvalMap.Map1Texture2.u2;
  1343.            break;
  1344.         case GL_MAP1_TEXTURE_COORD_3:
  1345.            v[0] = ctx->EvalMap.Map1Texture3.u1;
  1346.            v[1] = ctx->EvalMap.Map1Texture3.u2;
  1347.            break;
  1348.         case GL_MAP1_TEXTURE_COORD_4:
  1349.            v[0] = ctx->EvalMap.Map1Texture4.u1;
  1350.            v[1] = ctx->EvalMap.Map1Texture4.u2;
  1351.            break;
  1352.         case GL_MAP1_VERTEX_3:
  1353.            v[0] = ctx->EvalMap.Map1Vertex3.u1;
  1354.            v[1] = ctx->EvalMap.Map1Vertex3.u2;
  1355.            break;
  1356.         case GL_MAP1_VERTEX_4:
  1357.            v[0] = ctx->EvalMap.Map1Vertex4.u1;
  1358.            v[1] = ctx->EvalMap.Map1Vertex4.u2;
  1359.            break;
  1360.         case GL_MAP2_COLOR_4:
  1361.            v[0] = ctx->EvalMap.Map2Color4.u1;
  1362.            v[1] = ctx->EvalMap.Map2Color4.u2;
  1363.            v[2] = ctx->EvalMap.Map2Color4.v1;
  1364.            v[3] = ctx->EvalMap.Map2Color4.v2;
  1365.            break;
  1366.         case GL_MAP2_INDEX:
  1367.            v[0] = ctx->EvalMap.Map2Index.u1;
  1368.            v[1] = ctx->EvalMap.Map2Index.u2;
  1369.            v[2] = ctx->EvalMap.Map2Index.v1;
  1370.            v[3] = ctx->EvalMap.Map2Index.v2;
  1371.            break;
  1372.         case GL_MAP2_NORMAL:
  1373.            v[0] = ctx->EvalMap.Map2Normal.u1;
  1374.            v[1] = ctx->EvalMap.Map2Normal.u2;
  1375.            v[2] = ctx->EvalMap.Map2Normal.v1;
  1376.            v[3] = ctx->EvalMap.Map2Normal.v2;
  1377.            break;
  1378.         case GL_MAP2_TEXTURE_COORD_1:
  1379.            v[0] = ctx->EvalMap.Map2Texture1.u1;
  1380.            v[1] = ctx->EvalMap.Map2Texture1.u2;
  1381.            v[2] = ctx->EvalMap.Map2Texture1.v1;
  1382.            v[3] = ctx->EvalMap.Map2Texture1.v2;
  1383.            break;
  1384.         case GL_MAP2_TEXTURE_COORD_2:
  1385.            v[0] = ctx->EvalMap.Map2Texture2.u1;
  1386.            v[1] = ctx->EvalMap.Map2Texture2.u2;
  1387.            v[2] = ctx->EvalMap.Map2Texture2.v1;
  1388.            v[3] = ctx->EvalMap.Map2Texture2.v2;
  1389.            break;
  1390.         case GL_MAP2_TEXTURE_COORD_3:
  1391.            v[0] = ctx->EvalMap.Map2Texture3.u1;
  1392.            v[1] = ctx->EvalMap.Map2Texture3.u2;
  1393.            v[2] = ctx->EvalMap.Map2Texture3.v1;
  1394.            v[3] = ctx->EvalMap.Map2Texture3.v2;
  1395.            break;
  1396.         case GL_MAP2_TEXTURE_COORD_4:
  1397.            v[0] = ctx->EvalMap.Map2Texture4.u1;
  1398.            v[1] = ctx->EvalMap.Map2Texture4.u2;
  1399.            v[2] = ctx->EvalMap.Map2Texture4.v1;
  1400.            v[3] = ctx->EvalMap.Map2Texture4.v2;
  1401.            break;
  1402.         case GL_MAP2_VERTEX_3:
  1403.            v[0] = ctx->EvalMap.Map2Vertex3.u1;
  1404.            v[1] = ctx->EvalMap.Map2Vertex3.u2;
  1405.            v[2] = ctx->EvalMap.Map2Vertex3.v1;
  1406.            v[3] = ctx->EvalMap.Map2Vertex3.v2;
  1407.            break;
  1408.         case GL_MAP2_VERTEX_4:
  1409.            v[0] = ctx->EvalMap.Map2Vertex4.u1;
  1410.            v[1] = ctx->EvalMap.Map2Vertex4.u2;
  1411.            v[2] = ctx->EvalMap.Map2Vertex4.v1;
  1412.            v[3] = ctx->EvalMap.Map2Vertex4.v2;
  1413.            break;
  1414.         default:
  1415.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
  1416.      }
  1417.      break;
  1418.       default:
  1419.      gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
  1420.    }
  1421. }
  1422.  
  1423.  
  1424. void gl_GetMapfv( GLcontext* ctx, GLenum target, GLenum query, GLfloat *v )
  1425. {
  1426.    GLuint i, n;
  1427.    GLfloat *data;
  1428.  
  1429.    switch (query) {
  1430.       case GL_COEFF:
  1431.      switch (target) {
  1432.         case GL_MAP1_COLOR_4:
  1433.            data = ctx->EvalMap.Map1Color4.Points;
  1434.            n = ctx->EvalMap.Map1Color4.Order * 4;
  1435.            break;
  1436.         case GL_MAP1_INDEX:
  1437.            data = ctx->EvalMap.Map1Index.Points;
  1438.            n = ctx->EvalMap.Map1Index.Order;
  1439.            break;
  1440.         case GL_MAP1_NORMAL:
  1441.            data = ctx->EvalMap.Map1Normal.Points;
  1442.            n = ctx->EvalMap.Map1Normal.Order * 3;
  1443.            break;
  1444.         case GL_MAP1_TEXTURE_COORD_1:
  1445.            data = ctx->EvalMap.Map1Texture1.Points;
  1446.            n = ctx->EvalMap.Map1Texture1.Order * 1;
  1447.            break;
  1448.         case GL_MAP1_TEXTURE_COORD_2:
  1449.            data = ctx->EvalMap.Map1Texture2.Points;
  1450.            n = ctx->EvalMap.Map1Texture2.Order * 2;
  1451.            break;
  1452.         case GL_MAP1_TEXTURE_COORD_3:
  1453.            data = ctx->EvalMap.Map1Texture3.Points;
  1454.            n = ctx->EvalMap.Map1Texture3.Order * 3;
  1455.            break;
  1456.         case GL_MAP1_TEXTURE_COORD_4:
  1457.            data = ctx->EvalMap.Map1Texture4.Points;
  1458.            n = ctx->EvalMap.Map1Texture4.Order * 4;
  1459.            break;
  1460.         case GL_MAP1_VERTEX_3:
  1461.            data = ctx->EvalMap.Map1Vertex3.Points;
  1462.            n = ctx->EvalMap.Map1Vertex3.Order * 3;
  1463.            break;
  1464.         case GL_MAP1_VERTEX_4:
  1465.            data = ctx->EvalMap.Map1Vertex4.Points;
  1466.            n = ctx->EvalMap.Map1Vertex4.Order * 4;
  1467.            break;
  1468.         case GL_MAP2_COLOR_4:
  1469.            data = ctx->EvalMap.Map2Color4.Points;
  1470.            n = ctx->EvalMap.Map2Color4.Uorder
  1471.          * ctx->EvalMap.Map2Color4.Vorder * 4;
  1472.            break;
  1473.         case GL_MAP2_INDEX:
  1474.            data = ctx->EvalMap.Map2Index.Points;
  1475.            n = ctx->EvalMap.Map2Index.Uorder
  1476.          * ctx->EvalMap.Map2Index.Vorder;
  1477.            break;
  1478.         case GL_MAP2_NORMAL:
  1479.            data = ctx->EvalMap.Map2Normal.Points;
  1480.            n = ctx->EvalMap.Map2Normal.Uorder
  1481.          * ctx->EvalMap.Map2Normal.Vorder * 3;
  1482.            break;
  1483.         case GL_MAP2_TEXTURE_COORD_1:
  1484.            data = ctx->EvalMap.Map2Texture1.Points;
  1485.            n = ctx->EvalMap.Map2Texture1.Uorder
  1486.          * ctx->EvalMap.Map2Texture1.Vorder * 1;
  1487.            break;
  1488.         case GL_MAP2_TEXTURE_COORD_2:
  1489.            data = ctx->EvalMap.Map2Texture2.Points;
  1490.            n = ctx->EvalMap.Map2Texture2.Uorder
  1491.          * ctx->EvalMap.Map2Texture2.Vorder * 2;
  1492.            break;
  1493.         case GL_MAP2_TEXTURE_COORD_3:
  1494.            data = ctx->EvalMap.Map2Texture3.Points;
  1495.            n = ctx->EvalMap.Map2Texture3.Uorder
  1496.          * ctx->EvalMap.Map2Texture3.Vorder * 3;
  1497.            break;
  1498.         case GL_MAP2_TEXTURE_COORD_4:
  1499.            data = ctx->EvalMap.Map2Texture4.Points;
  1500.            n = ctx->EvalMap.Map2Texture4.Uorder
  1501.          * ctx->EvalMap.Map2Texture4.Vorder * 4;
  1502.            break;
  1503.         case GL_MAP2_VERTEX_3:
  1504.            data = ctx->EvalMap.Map2Vertex3.Points;
  1505.            n = ctx->EvalMap.Map2Vertex3.Uorder
  1506.          * ctx->EvalMap.Map2Vertex3.Vorder * 3;
  1507.            break;
  1508.         case GL_MAP2_VERTEX_4:
  1509.            data = ctx->EvalMap.Map2Vertex4.Points;
  1510.            n = ctx->EvalMap.Map2Vertex4.Uorder
  1511.          * ctx->EvalMap.Map2Vertex4.Vorder * 4;
  1512.            break;
  1513.         default:
  1514.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
  1515.      }
  1516.      if (data) {
  1517.         for (i=0;i<n;i++) {
  1518.            v[i] = data[i];
  1519.         }
  1520.      }
  1521.      break;
  1522.       case GL_ORDER:
  1523.      switch (target) {
  1524.         case GL_MAP1_COLOR_4:
  1525.            *v = ctx->EvalMap.Map1Color4.Order;
  1526.            break;
  1527.         case GL_MAP1_INDEX:
  1528.            *v = ctx->EvalMap.Map1Index.Order;
  1529.            break;
  1530.         case GL_MAP1_NORMAL:
  1531.            *v = ctx->EvalMap.Map1Normal.Order;
  1532.            break;
  1533.         case GL_MAP1_TEXTURE_COORD_1:
  1534.            *v = ctx->EvalMap.Map1Texture1.Order;
  1535.            break;
  1536.         case GL_MAP1_TEXTURE_COORD_2:
  1537.            *v = ctx->EvalMap.Map1Texture2.Order;
  1538.            break;
  1539.         case GL_MAP1_TEXTURE_COORD_3:
  1540.            *v = ctx->EvalMap.Map1Texture3.Order;
  1541.            break;
  1542.         case GL_MAP1_TEXTURE_COORD_4:
  1543.            *v = ctx->EvalMap.Map1Texture4.Order;
  1544.            break;
  1545.         case GL_MAP1_VERTEX_3:
  1546.            *v = ctx->EvalMap.Map1Vertex3.Order;
  1547.            break;
  1548.         case GL_MAP1_VERTEX_4:
  1549.            *v = ctx->EvalMap.Map1Vertex4.Order;
  1550.            break;
  1551.         case GL_MAP2_COLOR_4:
  1552.            v[0] = ctx->EvalMap.Map2Color4.Uorder;
  1553.            v[1] = ctx->EvalMap.Map2Color4.Vorder;
  1554.            break;
  1555.         case GL_MAP2_INDEX:
  1556.            v[0] = ctx->EvalMap.Map2Index.Uorder;
  1557.            v[1] = ctx->EvalMap.Map2Index.Vorder;
  1558.            break;
  1559.         case GL_MAP2_NORMAL:
  1560.            v[0] = ctx->EvalMap.Map2Normal.Uorder;
  1561.            v[1] = ctx->EvalMap.Map2Normal.Vorder;
  1562.            break;
  1563.         case GL_MAP2_TEXTURE_COORD_1:
  1564.            v[0] = ctx->EvalMap.Map2Texture1.Uorder;
  1565.            v[1] = ctx->EvalMap.Map2Texture1.Vorder;
  1566.            break;
  1567.         case GL_MAP2_TEXTURE_COORD_2:
  1568.            v[0] = ctx->EvalMap.Map2Texture2.Uorder;
  1569.            v[1] = ctx->EvalMap.Map2Texture2.Vorder;
  1570.            break;
  1571.         case GL_MAP2_TEXTURE_COORD_3:
  1572.            v[0] = ctx->EvalMap.Map2Texture3.Uorder;
  1573.            v[1] = ctx->EvalMap.Map2Texture3.Vorder;
  1574.            break;
  1575.         case GL_MAP2_TEXTURE_COORD_4:
  1576.            v[0] = ctx->EvalMap.Map2Texture4.Uorder;
  1577.            v[1] = ctx->EvalMap.Map2Texture4.Vorder;
  1578.            break;
  1579.         case GL_MAP2_VERTEX_3:
  1580.            v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
  1581.            v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
  1582.            break;
  1583.         case GL_MAP2_VERTEX_4:
  1584.            v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
  1585.            v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
  1586.            break;
  1587.         default:
  1588.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
  1589.      }
  1590.      break;
  1591.       case GL_DOMAIN:
  1592.      switch (target) {
  1593.         case GL_MAP1_COLOR_4:
  1594.            v[0] = ctx->EvalMap.Map1Color4.u1;
  1595.            v[1] = ctx->EvalMap.Map1Color4.u2;
  1596.            break;
  1597.         case GL_MAP1_INDEX:
  1598.            v[0] = ctx->EvalMap.Map1Index.u1;
  1599.            v[1] = ctx->EvalMap.Map1Index.u2;
  1600.            break;
  1601.         case GL_MAP1_NORMAL:
  1602.            v[0] = ctx->EvalMap.Map1Normal.u1;
  1603.            v[1] = ctx->EvalMap.Map1Normal.u2;
  1604.            break;
  1605.         case GL_MAP1_TEXTURE_COORD_1:
  1606.            v[0] = ctx->EvalMap.Map1Texture1.u1;
  1607.            v[1] = ctx->EvalMap.Map1Texture1.u2;
  1608.            break;
  1609.         case GL_MAP1_TEXTURE_COORD_2:
  1610.            v[0] = ctx->EvalMap.Map1Texture2.u1;
  1611.            v[1] = ctx->EvalMap.Map1Texture2.u2;
  1612.            break;
  1613.         case GL_MAP1_TEXTURE_COORD_3:
  1614.            v[0] = ctx->EvalMap.Map1Texture3.u1;
  1615.            v[1] = ctx->EvalMap.Map1Texture3.u2;
  1616.            break;
  1617.         case GL_MAP1_TEXTURE_COORD_4:
  1618.            v[0] = ctx->EvalMap.Map1Texture4.u1;
  1619.            v[1] = ctx->EvalMap.Map1Texture4.u2;
  1620.            break;
  1621.         case GL_MAP1_VERTEX_3:
  1622.            v[0] = ctx->EvalMap.Map1Vertex3.u1;
  1623.            v[1] = ctx->EvalMap.Map1Vertex3.u2;
  1624.            break;
  1625.         case GL_MAP1_VERTEX_4:
  1626.            v[0] = ctx->EvalMap.Map1Vertex4.u1;
  1627.            v[1] = ctx->EvalMap.Map1Vertex4.u2;
  1628.            break;
  1629.         case GL_MAP2_COLOR_4:
  1630.            v[0] = ctx->EvalMap.Map2Color4.u1;
  1631.            v[1] = ctx->EvalMap.Map2Color4.u2;
  1632.            v[2] = ctx->EvalMap.Map2Color4.v1;
  1633.            v[3] = ctx->EvalMap.Map2Color4.v2;
  1634.            break;
  1635.         case GL_MAP2_INDEX:
  1636.            v[0] = ctx->EvalMap.Map2Index.u1;
  1637.            v[1] = ctx->EvalMap.Map2Index.u2;
  1638.            v[2] = ctx->EvalMap.Map2Index.v1;
  1639.            v[3] = ctx->EvalMap.Map2Index.v2;
  1640.            break;
  1641.         case GL_MAP2_NORMAL:
  1642.            v[0] = ctx->EvalMap.Map2Normal.u1;
  1643.            v[1] = ctx->EvalMap.Map2Normal.u2;
  1644.            v[2] = ctx->EvalMap.Map2Normal.v1;
  1645.            v[3] = ctx->EvalMap.Map2Normal.v2;
  1646.            break;
  1647.         case GL_MAP2_TEXTURE_COORD_1:
  1648.            v[0] = ctx->EvalMap.Map2Texture1.u1;
  1649.            v[1] = ctx->EvalMap.Map2Texture1.u2;
  1650.            v[2] = ctx->EvalMap.Map2Texture1.v1;
  1651.            v[3] = ctx->EvalMap.Map2Texture1.v2;
  1652.            break;
  1653.         case GL_MAP2_TEXTURE_COORD_2:
  1654.            v[0] = ctx->EvalMap.Map2Texture2.u1;
  1655.            v[1] = ctx->EvalMap.Map2Texture2.u2;
  1656.            v[2] = ctx->EvalMap.Map2Texture2.v1;
  1657.            v[3] = ctx->EvalMap.Map2Texture2.v2;
  1658.            break;
  1659.         case GL_MAP2_TEXTURE_COORD_3:
  1660.            v[0] = ctx->EvalMap.Map2Texture3.u1;
  1661.            v[1] = ctx->EvalMap.Map2Texture3.u2;
  1662.            v[2] = ctx->EvalMap.Map2Texture3.v1;
  1663.            v[3] = ctx->EvalMap.Map2Texture3.v2;
  1664.            break;
  1665.         case GL_MAP2_TEXTURE_COORD_4:
  1666.            v[0] = ctx->EvalMap.Map2Texture4.u1;
  1667.            v[1] = ctx->EvalMap.Map2Texture4.u2;
  1668.            v[2] = ctx->EvalMap.Map2Texture4.v1;
  1669.            v[3] = ctx->EvalMap.Map2Texture4.v2;
  1670.            break;
  1671.         case GL_MAP2_VERTEX_3:
  1672.            v[0] = ctx->EvalMap.Map2Vertex3.u1;
  1673.            v[1] = ctx->EvalMap.Map2Vertex3.u2;
  1674.            v[2] = ctx->EvalMap.Map2Vertex3.v1;
  1675.            v[3] = ctx->EvalMap.Map2Vertex3.v2;
  1676.            break;
  1677.         case GL_MAP2_VERTEX_4:
  1678.            v[0] = ctx->EvalMap.Map2Vertex4.u1;
  1679.            v[1] = ctx->EvalMap.Map2Vertex4.u2;
  1680.            v[2] = ctx->EvalMap.Map2Vertex4.v1;
  1681.            v[3] = ctx->EvalMap.Map2Vertex4.v2;
  1682.            break;
  1683.         default:
  1684.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
  1685.      }
  1686.      break;
  1687.       default:
  1688.      gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
  1689.    }
  1690. }
  1691.  
  1692.  
  1693. void gl_GetMapiv( GLcontext* ctx, GLenum target, GLenum query, GLint *v )
  1694. {
  1695.    GLuint i, n;
  1696.    GLfloat *data;
  1697.  
  1698.    switch (query) {
  1699.       case GL_COEFF:
  1700.      switch (target) {
  1701.         case GL_MAP1_COLOR_4:
  1702.            data = ctx->EvalMap.Map1Color4.Points;
  1703.            n = ctx->EvalMap.Map1Color4.Order * 4;
  1704.            break;
  1705.         case GL_MAP1_INDEX:
  1706.            data = ctx->EvalMap.Map1Index.Points;
  1707.            n = ctx->EvalMap.Map1Index.Order;
  1708.            break;
  1709.         case GL_MAP1_NORMAL:
  1710.            data = ctx->EvalMap.Map1Normal.Points;
  1711.            n = ctx->EvalMap.Map1Normal.Order * 3;
  1712.            break;
  1713.         case GL_MAP1_TEXTURE_COORD_1:
  1714.            data = ctx->EvalMap.Map1Texture1.Points;
  1715.            n = ctx->EvalMap.Map1Texture1.Order * 1;
  1716.            break;
  1717.         case GL_MAP1_TEXTURE_COORD_2:
  1718.            data = ctx->EvalMap.Map1Texture2.Points;
  1719.            n = ctx->EvalMap.Map1Texture2.Order * 2;
  1720.            break;
  1721.         case GL_MAP1_TEXTURE_COORD_3:
  1722.            data = ctx->EvalMap.Map1Texture3.Points;
  1723.            n = ctx->EvalMap.Map1Texture3.Order * 3;
  1724.            break;
  1725.         case GL_MAP1_TEXTURE_COORD_4:
  1726.            data = ctx->EvalMap.Map1Texture4.Points;
  1727.            n = ctx->EvalMap.Map1Texture4.Order * 4;
  1728.            break;
  1729.         case GL_MAP1_VERTEX_3:
  1730.            data = ctx->EvalMap.Map1Vertex3.Points;
  1731.            n = ctx->EvalMap.Map1Vertex3.Order * 3;
  1732.            break;
  1733.         case GL_MAP1_VERTEX_4:
  1734.            data = ctx->EvalMap.Map1Vertex4.Points;
  1735.            n = ctx->EvalMap.Map1Vertex4.Order * 4;
  1736.            break;
  1737.         case GL_MAP2_COLOR_4:
  1738.            data = ctx->EvalMap.Map2Color4.Points;
  1739.            n = ctx->EvalMap.Map2Color4.Uorder
  1740.          * ctx->EvalMap.Map2Color4.Vorder * 4;
  1741.            break;
  1742.         case GL_MAP2_INDEX:
  1743.            data = ctx->EvalMap.Map2Index.Points;
  1744.            n = ctx->EvalMap.Map2Index.Uorder
  1745.          * ctx->EvalMap.Map2Index.Vorder;
  1746.            break;
  1747.         case GL_MAP2_NORMAL:
  1748.            data = ctx->EvalMap.Map2Normal.Points;
  1749.            n = ctx->EvalMap.Map2Normal.Uorder
  1750.          * ctx->EvalMap.Map2Normal.Vorder * 3;
  1751.            break;
  1752.         case GL_MAP2_TEXTURE_COORD_1:
  1753.            data = ctx->EvalMap.Map2Texture1.Points;
  1754.            n = ctx->EvalMap.Map2Texture1.Uorder
  1755.          * ctx->EvalMap.Map2Texture1.Vorder * 1;
  1756.            break;
  1757.         case GL_MAP2_TEXTURE_COORD_2:
  1758.            data = ctx->EvalMap.Map2Texture2.Points;
  1759.            n = ctx->EvalMap.Map2Texture2.Uorder
  1760.          * ctx->EvalMap.Map2Texture2.Vorder * 2;
  1761.            break;
  1762.         case GL_MAP2_TEXTURE_COORD_3:
  1763.            data = ctx->EvalMap.Map2Texture3.Points;
  1764.            n = ctx->EvalMap.Map2Texture3.Uorder
  1765.          * ctx->EvalMap.Map2Texture3.Vorder * 3;
  1766.            break;
  1767.         case GL_MAP2_TEXTURE_COORD_4:
  1768.            data = ctx->EvalMap.Map2Texture4.Points;
  1769.            n = ctx->EvalMap.Map2Texture4.Uorder
  1770.          * ctx->EvalMap.Map2Texture4.Vorder * 4;
  1771.            break;
  1772.         case GL_MAP2_VERTEX_3:
  1773.            data = ctx->EvalMap.Map2Vertex3.Points;
  1774.            n = ctx->EvalMap.Map2Vertex3.Uorder
  1775.          * ctx->EvalMap.Map2Vertex3.Vorder * 3;
  1776.            break;
  1777.         case GL_MAP2_VERTEX_4:
  1778.            data = ctx->EvalMap.Map2Vertex4.Points;
  1779.            n = ctx->EvalMap.Map2Vertex4.Uorder
  1780.          * ctx->EvalMap.Map2Vertex4.Vorder * 4;
  1781.            break;
  1782.         default:
  1783.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
  1784.      }
  1785.      if (data) {
  1786.         for (i=0;i<n;i++) {
  1787.            v[i] = ROUNDF(data[i]);
  1788.         }
  1789.      }
  1790.      break;
  1791.       case GL_ORDER:
  1792.      switch (target) {
  1793.         case GL_MAP1_COLOR_4:
  1794.            *v = ctx->EvalMap.Map1Color4.Order;
  1795.            break;
  1796.         case GL_MAP1_INDEX:
  1797.            *v = ctx->EvalMap.Map1Index.Order;
  1798.            break;
  1799.         case GL_MAP1_NORMAL:
  1800.            *v = ctx->EvalMap.Map1Normal.Order;
  1801.            break;
  1802.         case GL_MAP1_TEXTURE_COORD_1:
  1803.            *v = ctx->EvalMap.Map1Texture1.Order;
  1804.            break;
  1805.         case GL_MAP1_TEXTURE_COORD_2:
  1806.            *v = ctx->EvalMap.Map1Texture2.Order;
  1807.            break;
  1808.         case GL_MAP1_TEXTURE_COORD_3:
  1809.            *v = ctx->EvalMap.Map1Texture3.Order;
  1810.            break;
  1811.         case GL_MAP1_TEXTURE_COORD_4:
  1812.            *v = ctx->EvalMap.Map1Texture4.Order;
  1813.            break;
  1814.         case GL_MAP1_VERTEX_3:
  1815.            *v = ctx->EvalMap.Map1Vertex3.Order;
  1816.            break;
  1817.         case GL_MAP1_VERTEX_4:
  1818.            *v = ctx->EvalMap.Map1Vertex4.Order;
  1819.            break;
  1820.         case GL_MAP2_COLOR_4:
  1821.            v[0] = ctx->EvalMap.Map2Color4.Uorder;
  1822.            v[1] = ctx->EvalMap.Map2Color4.Vorder;
  1823.            break;
  1824.         case GL_MAP2_INDEX:
  1825.            v[0] = ctx->EvalMap.Map2Index.Uorder;
  1826.            v[1] = ctx->EvalMap.Map2Index.Vorder;
  1827.            break;
  1828.         case GL_MAP2_NORMAL:
  1829.            v[0] = ctx->EvalMap.Map2Normal.Uorder;
  1830.            v[1] = ctx->EvalMap.Map2Normal.Vorder;
  1831.            break;
  1832.         case GL_MAP2_TEXTURE_COORD_1:
  1833.            v[0] = ctx->EvalMap.Map2Texture1.Uorder;
  1834.            v[1] = ctx->EvalMap.Map2Texture1.Vorder;
  1835.            break;
  1836.         case GL_MAP2_TEXTURE_COORD_2:
  1837.            v[0] = ctx->EvalMap.Map2Texture2.Uorder;
  1838.            v[1] = ctx->EvalMap.Map2Texture2.Vorder;
  1839.            break;
  1840.         case GL_MAP2_TEXTURE_COORD_3:
  1841.            v[0] = ctx->EvalMap.Map2Texture3.Uorder;
  1842.            v[1] = ctx->EvalMap.Map2Texture3.Vorder;
  1843.            break;
  1844.         case GL_MAP2_TEXTURE_COORD_4:
  1845.            v[0] = ctx->EvalMap.Map2Texture4.Uorder;
  1846.            v[1] = ctx->EvalMap.Map2Texture4.Vorder;
  1847.            break;
  1848.         case GL_MAP2_VERTEX_3:
  1849.            v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
  1850.            v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
  1851.            break;
  1852.         case GL_MAP2_VERTEX_4:
  1853.            v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
  1854.            v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
  1855.            break;
  1856.         default:
  1857.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
  1858.      }
  1859.      break;
  1860.       case GL_DOMAIN:
  1861.      switch (target) {
  1862.         case GL_MAP1_COLOR_4:
  1863.            v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
  1864.            v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
  1865.            break;
  1866.         case GL_MAP1_INDEX:
  1867.            v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
  1868.            v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
  1869.            break;
  1870.         case GL_MAP1_NORMAL:
  1871.            v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
  1872.            v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
  1873.            break;
  1874.         case GL_MAP1_TEXTURE_COORD_1:
  1875.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
  1876.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
  1877.            break;
  1878.         case GL_MAP1_TEXTURE_COORD_2:
  1879.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
  1880.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
  1881.            break;
  1882.         case GL_MAP1_TEXTURE_COORD_3:
  1883.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
  1884.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
  1885.            break;
  1886.         case GL_MAP1_TEXTURE_COORD_4:
  1887.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
  1888.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
  1889.            break;
  1890.         case GL_MAP1_VERTEX_3:
  1891.            v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
  1892.            v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
  1893.            break;
  1894.         case GL_MAP1_VERTEX_4:
  1895.            v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
  1896.            v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
  1897.            break;
  1898.         case GL_MAP2_COLOR_4:
  1899.            v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
  1900.            v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
  1901.            v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
  1902.            v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
  1903.            break;
  1904.         case GL_MAP2_INDEX:
  1905.            v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
  1906.            v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
  1907.            v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
  1908.            v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
  1909.            break;
  1910.         case GL_MAP2_NORMAL:
  1911.            v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
  1912.            v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
  1913.            v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
  1914.            v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
  1915.            break;
  1916.         case GL_MAP2_TEXTURE_COORD_1:
  1917.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
  1918.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
  1919.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
  1920.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
  1921.            break;
  1922.         case GL_MAP2_TEXTURE_COORD_2:
  1923.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
  1924.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
  1925.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
  1926.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
  1927.            break;
  1928.         case GL_MAP2_TEXTURE_COORD_3:
  1929.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
  1930.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
  1931.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
  1932.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
  1933.            break;
  1934.         case GL_MAP2_TEXTURE_COORD_4:
  1935.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
  1936.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
  1937.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
  1938.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
  1939.            break;
  1940.         case GL_MAP2_VERTEX_3:
  1941.            v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
  1942.            v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
  1943.            v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
  1944.            v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
  1945.            break;
  1946.         case GL_MAP2_VERTEX_4:
  1947.            v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
  1948.            v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
  1949.            v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
  1950.            v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
  1951.            break;
  1952.         default:
  1953.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
  1954.      }
  1955.      break;
  1956.       default:
  1957.      gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
  1958.    }
  1959. }
  1960.  
  1961.  
  1962.  
  1963. void gl_EvalCoord1f(GLcontext* ctx, GLfloat u)
  1964. {
  1965.   GLfloat vertex[4];
  1966.   GLfloat normal[3];
  1967.   GLfloat fcolor[4];
  1968.   GLubyte icolor[4];
  1969.   GLubyte *colorptr;
  1970.   GLfloat texcoord[4];
  1971.   GLuint index;
  1972.   register GLfloat uu;
  1973.  
  1974.   /** Vertex **/
  1975.   if (ctx->Eval.Map1Vertex4) 
  1976.   {
  1977.      struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex4;
  1978.      uu = (u - map->u1) / (map->u2 - map->u1);
  1979.      horner_bezier_curve(map->Points, vertex, uu, 4, map->Order);
  1980.   }
  1981.   else if (ctx->Eval.Map1Vertex3) 
  1982.   {
  1983.      struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex3;
  1984.      uu = (u - map->u1) / (map->u2 - map->u1);
  1985.      horner_bezier_curve(map->Points, vertex, uu, 3, map->Order);
  1986.      vertex[3] = 1.0;
  1987.   }
  1988.  
  1989.   /** Color Index **/
  1990.   if (ctx->Eval.Map1Index) 
  1991.   {
  1992.      struct gl_1d_map *map = &ctx->EvalMap.Map1Index;
  1993.      GLfloat findex;
  1994.      uu = (u - map->u1) / (map->u2 - map->u1);
  1995.      horner_bezier_curve(map->Points, &findex, uu, 1, map->Order);
  1996.      index = (GLuint) (GLint) findex;
  1997.   }
  1998.   else {
  1999.      index = ctx->Current.Index;
  2000.   }
  2001.  
  2002.   /** Color **/
  2003.   if (ctx->Eval.Map1Color4) {
  2004.      struct gl_1d_map *map = &ctx->EvalMap.Map1Color4;
  2005.      uu = (u - map->u1) / (map->u2 - map->u1);
  2006.      horner_bezier_curve(map->Points, fcolor, uu, 4, map->Order);
  2007.      icolor[0] = (GLint) (fcolor[0] * ctx->Visual->RedScale);
  2008.      icolor[1] = (GLint) (fcolor[1] * ctx->Visual->GreenScale);
  2009.      icolor[2] = (GLint) (fcolor[2] * ctx->Visual->BlueScale);
  2010.      icolor[3] = (GLint) (fcolor[3] * ctx->Visual->AlphaScale);
  2011.      colorptr = icolor;
  2012.   }
  2013.   else {
  2014.      GLubyte col[4];
  2015.      COPY_4V(col, ctx->Current.ByteColor );
  2016.      colorptr = col;
  2017.   }
  2018.  
  2019.   /** Normal Vector **/
  2020.   if (ctx->Eval.Map1Normal) {
  2021.      struct gl_1d_map *map = &ctx->EvalMap.Map1Normal;
  2022.      uu = (u - map->u1) / (map->u2 - map->u1);
  2023.      horner_bezier_curve(map->Points, normal, uu, 3, map->Order);
  2024.   }
  2025.   else {
  2026.     normal[0] = ctx->Current.Normal[0];
  2027.     normal[1] = ctx->Current.Normal[1];
  2028.     normal[2] = ctx->Current.Normal[2];
  2029.   }
  2030.  
  2031.   /** Texture Coordinates **/
  2032.   if (ctx->Eval.Map1TextureCoord4) {
  2033.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture4;
  2034.      uu = (u - map->u1) / (map->u2 - map->u1);
  2035.      horner_bezier_curve(map->Points, texcoord, uu, 4, map->Order);
  2036.   }
  2037.   else if (ctx->Eval.Map1TextureCoord3) {
  2038.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture3;
  2039.      uu = (u - map->u1) / (map->u2 - map->u1);
  2040.      horner_bezier_curve(map->Points, texcoord, uu, 3, map->Order);
  2041.      texcoord[3] = 1.0;
  2042.   }
  2043.   else if (ctx->Eval.Map1TextureCoord2) {
  2044.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture2;
  2045.      uu = (u - map->u1) / (map->u2 - map->u1);
  2046.      horner_bezier_curve(map->Points, texcoord, uu, 2, map->Order);
  2047.      texcoord[2] = 0.0;
  2048.      texcoord[3] = 1.0;
  2049.   }
  2050.   else if (ctx->Eval.Map1TextureCoord1) {
  2051.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture1;
  2052.      uu = (u - map->u1) / (map->u2 - map->u1);
  2053.      horner_bezier_curve(map->Points, texcoord, uu, 1, map->Order);
  2054.      texcoord[1] = 0.0;
  2055.      texcoord[2] = 0.0;
  2056.      texcoord[3] = 1.0;
  2057.   }
  2058.   else {
  2059.      texcoord[0] = ctx->Current.TexCoord[0];
  2060.      texcoord[1] = ctx->Current.TexCoord[1];
  2061.      texcoord[2] = ctx->Current.TexCoord[2];
  2062.      texcoord[3] = ctx->Current.TexCoord[3];
  2063.   }
  2064.   
  2065.   gl_eval_vertex( ctx, vertex, normal, colorptr, index, texcoord );
  2066. }
  2067.  
  2068.  
  2069. void gl_EvalCoord2f( GLcontext* ctx, GLfloat u, GLfloat v )
  2070. {
  2071.    GLfloat vertex[4];
  2072.    GLfloat normal[3];
  2073.    GLfloat fcolor[4];
  2074.    GLubyte icolor[4];
  2075.    GLubyte *colorptr;
  2076.    GLfloat texcoord[4];
  2077.    GLuint index;
  2078.    register GLfloat uu, vv;
  2079.  
  2080. #define CROSS_PROD(n, u, v) \
  2081.   (n)[0] = (u)[1]*(v)[2] - (u)[2]*(v)[1]; \
  2082.   (n)[1] = (u)[2]*(v)[0] - (u)[0]*(v)[2]; \
  2083.   (n)[2] = (u)[0]*(v)[1] - (u)[1]*(v)[0]
  2084.  
  2085.    /** Vertex **/
  2086.    if(ctx->Eval.Map2Vertex4) {
  2087.       struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex4;
  2088.       uu = (u - map->u1) / (map->u2 - map->u1);
  2089.       vv = (v - map->v1) / (map->v2 - map->v1);
  2090.  
  2091.       if (ctx->Eval.AutoNormal) {
  2092.      GLfloat du[4], dv[4];
  2093.  
  2094.      de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 4,
  2095.                map->Uorder, map->Vorder);
  2096.  
  2097.      CROSS_PROD(normal, du, dv);
  2098.      NORMALIZE_3FV(normal);
  2099.       }
  2100.       else {
  2101.      horner_bezier_surf(map->Points, vertex, uu, vv, 4,
  2102.                 map->Uorder, map->Vorder);
  2103.       }
  2104.    }
  2105.    else if (ctx->Eval.Map2Vertex3) {
  2106.       struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex3;
  2107.       uu = (u - map->u1) / (map->u2 - map->u1);
  2108.       vv = (v - map->v1) / (map->v2 - map->v1);
  2109.       if (ctx->Eval.AutoNormal) {
  2110.      GLfloat du[3], dv[3];
  2111.      de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 3,
  2112.                map->Uorder, map->Vorder);
  2113.      CROSS_PROD(normal, du, dv);
  2114.      NORMALIZE_3FV(normal);
  2115.       }
  2116.       else {
  2117.      horner_bezier_surf(map->Points, vertex, uu, vv, 3,
  2118.                 map->Uorder, map->Vorder);
  2119.       }
  2120.       vertex[3] = 1.0;
  2121.    }
  2122. #undef CROSS_PROD
  2123.    
  2124.    /** Color Index **/
  2125.    if (ctx->Eval.Map2Index) {
  2126.       GLfloat findex;
  2127.       struct gl_2d_map *map = &ctx->EvalMap.Map2Index;
  2128.       uu = (u - map->u1) / (map->u2 - map->u1);
  2129.       vv = (v - map->v1) / (map->v2 - map->v1);
  2130.       horner_bezier_surf(map->Points, &findex, uu, vv, 1,
  2131.              map->Uorder, map->Vorder);
  2132.       index = (GLuint) (GLint) findex;
  2133.    }
  2134.    else {
  2135.       index = ctx->Current.Index;
  2136.    }
  2137.  
  2138.    /** Color **/
  2139.    if (ctx->Eval.Map2Color4) {
  2140.       struct gl_2d_map *map = &ctx->EvalMap.Map2Color4;
  2141.       uu = (u - map->u1) / (map->u2 - map->u1);
  2142.       vv = (v - map->v1) / (map->v2 - map->v1);
  2143.       horner_bezier_surf(map->Points, fcolor, uu, vv, 4,
  2144.              map->Uorder, map->Vorder);
  2145.       icolor[0] = (GLint) (fcolor[0] * ctx->Visual->RedScale);
  2146.       icolor[1] = (GLint) (fcolor[1] * ctx->Visual->GreenScale);
  2147.       icolor[2] = (GLint) (fcolor[2] * ctx->Visual->BlueScale);
  2148.       icolor[3] = (GLint) (fcolor[3] * ctx->Visual->AlphaScale);
  2149.       colorptr = icolor;
  2150.    }
  2151.    else {
  2152.      GLubyte col[4];
  2153.      COPY_4V(col, ctx->Current.ByteColor );
  2154.      colorptr = col;
  2155.    }
  2156.  
  2157.    /** Normal **/
  2158.    if (!ctx->Eval.AutoNormal
  2159.        || (!ctx->Eval.Map2Vertex3 && !ctx->Eval.Map2Vertex4)) {
  2160.       if (ctx->Eval.Map2Normal) {
  2161.      struct gl_2d_map *map = &ctx->EvalMap.Map2Normal;
  2162.      uu = (u - map->u1) / (map->u2 - map->u1);
  2163.      vv = (v - map->v1) / (map->v2 - map->v1);
  2164.      horner_bezier_surf(map->Points, normal, uu, vv, 3,
  2165.                 map->Uorder, map->Vorder);
  2166.       }
  2167.       else {
  2168.      normal[0] = ctx->Current.Normal[0];
  2169.      normal[1] = ctx->Current.Normal[1];
  2170.      normal[2] = ctx->Current.Normal[2];
  2171.       }
  2172.    }
  2173.  
  2174.    /** Texture Coordinates **/
  2175.    if (ctx->Eval.Map2TextureCoord4) {
  2176.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture4;
  2177.       uu = (u - map->u1) / (map->u2 - map->u1);
  2178.       vv = (v - map->v1) / (map->v2 - map->v1);
  2179.       horner_bezier_surf(map->Points, texcoord, uu, vv, 4,
  2180.              map->Uorder, map->Vorder);
  2181.    }
  2182.    else if (ctx->Eval.Map2TextureCoord3) {
  2183.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture3;
  2184.       uu = (u - map->u1) / (map->u2 - map->u1);
  2185.       vv = (v - map->v1) / (map->v2 - map->v1);
  2186.       horner_bezier_surf(map->Points, texcoord, uu, vv, 3,
  2187.              map->Uorder, map->Vorder);
  2188.      texcoord[3] = 1.0;
  2189.    }
  2190.    else if (ctx->Eval.Map2TextureCoord2) {
  2191.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture2;
  2192.       uu = (u - map->u1) / (map->u2 - map->u1);
  2193.       vv = (v - map->v1) / (map->v2 - map->v1);
  2194.       horner_bezier_surf(map->Points, texcoord, uu, vv, 2,
  2195.              map->Uorder, map->Vorder);
  2196.      texcoord[2] = 0.0;
  2197.      texcoord[3] = 1.0;
  2198.    }
  2199.    else if (ctx->Eval.Map2TextureCoord1) {
  2200.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture1;
  2201.       uu = (u - map->u1) / (map->u2 - map->u1);
  2202.       vv = (v - map->v1) / (map->v2 - map->v1);
  2203.       horner_bezier_surf(map->Points, texcoord, uu, vv, 1,
  2204.              map->Uorder, map->Vorder);
  2205.      texcoord[1] = 0.0;
  2206.      texcoord[2] = 0.0;
  2207.      texcoord[3] = 1.0;
  2208.    }
  2209.    else 
  2210.    {
  2211.      texcoord[0] = ctx->Current.TexCoord[0];
  2212.      texcoord[1] = ctx->Current.TexCoord[1];
  2213.      texcoord[2] = ctx->Current.TexCoord[2];
  2214.      texcoord[3] = ctx->Current.TexCoord[3];
  2215.    }
  2216.  
  2217.    gl_eval_vertex( ctx, vertex, normal, colorptr, index, texcoord );
  2218. }
  2219.  
  2220.  
  2221. void gl_MapGrid1f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2 )
  2222. {
  2223.    if (INSIDE_BEGIN_END(ctx)) {
  2224.       gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid1f" );
  2225.       return;
  2226.    }
  2227.    if (un<1) {
  2228.       gl_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
  2229.       return;
  2230.    }
  2231.    ctx->Eval.MapGrid1un = un;
  2232.    ctx->Eval.MapGrid1u1 = u1;
  2233.    ctx->Eval.MapGrid1u2 = u2;
  2234. }
  2235.  
  2236.  
  2237. void gl_MapGrid2f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2,
  2238.           GLint vn, GLfloat v1, GLfloat v2 )
  2239. {
  2240.    if (INSIDE_BEGIN_END(ctx)) {
  2241.       gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid2f" );
  2242.       return;
  2243.    }
  2244.    if (un<1) {
  2245.       gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
  2246.       return;
  2247.    }
  2248.    if (vn<1) {
  2249.       gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
  2250.       return;
  2251.    }
  2252.    ctx->Eval.MapGrid2un = un;
  2253.    ctx->Eval.MapGrid2u1 = u1;
  2254.    ctx->Eval.MapGrid2u2 = u2;
  2255.    ctx->Eval.MapGrid2vn = vn;
  2256.    ctx->Eval.MapGrid2v1 = v1;
  2257.    ctx->Eval.MapGrid2v2 = v2;
  2258. }
  2259.  
  2260.  
  2261. void gl_EvalPoint1( GLcontext* ctx, GLint i )
  2262. {
  2263.     GLfloat u, du;
  2264.  
  2265.     if (i==0) {
  2266.         u = ctx->Eval.MapGrid1u1;
  2267.     }
  2268.     else if (i==ctx->Eval.MapGrid1un) {
  2269.         u = ctx->Eval.MapGrid1u2;
  2270.     }
  2271.     else {
  2272.         du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
  2273.             / (GLfloat) ctx->Eval.MapGrid1un;
  2274.         u = i * du + ctx->Eval.MapGrid1u1;
  2275.     }
  2276.     gl_EvalCoord1f( ctx, u );
  2277. }
  2278.  
  2279.  
  2280.  
  2281. void gl_EvalPoint2( GLcontext* ctx, GLint i, GLint j )
  2282. {
  2283.     GLfloat u, du;
  2284.     GLfloat v, dv;
  2285.  
  2286.     if (i==0) {
  2287.         u = ctx->Eval.MapGrid2u1;
  2288.     }
  2289.     else if (i==ctx->Eval.MapGrid2un) {
  2290.         u = ctx->Eval.MapGrid2u2;
  2291.     }
  2292.     else {
  2293.         du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
  2294.             / (GLfloat) ctx->Eval.MapGrid2un;
  2295.         u = i * du + ctx->Eval.MapGrid2u1;
  2296.     }
  2297.  
  2298.     if (j==0) {
  2299.         v = ctx->Eval.MapGrid2v1;
  2300.     }
  2301.     else if (j==ctx->Eval.MapGrid2vn) {
  2302.         v = ctx->Eval.MapGrid2v2;
  2303.     }
  2304.     else {
  2305.         dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
  2306.             / (GLfloat) ctx->Eval.MapGrid2vn;
  2307.         v = j * dv + ctx->Eval.MapGrid2v1;
  2308.     }
  2309.  
  2310.     gl_EvalCoord2f( ctx, u, v );
  2311. }
  2312.  
  2313.  
  2314.  
  2315. void gl_EvalMesh1( GLcontext* ctx, GLenum mode, GLint i1, GLint i2 )
  2316. {
  2317.    GLint i;
  2318.    GLfloat u, du;
  2319.    GLenum prim;
  2320.  
  2321.     if (INSIDE_BEGIN_END(ctx)) {
  2322.         gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh1" );
  2323.         return;
  2324.     }
  2325.  
  2326.     switch (mode) {
  2327.     case GL_POINT:
  2328.         prim = GL_POINTS;
  2329.         break;
  2330.     case GL_LINE:
  2331.         prim = GL_LINE_STRIP;
  2332.         break;
  2333.     default:
  2334.         gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
  2335.         return;
  2336.     }
  2337.  
  2338.     du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
  2339.         / (GLfloat) ctx->Eval.MapGrid1un;
  2340.  
  2341.     gl_Begin( ctx, prim );
  2342.     for (i=i1;i<=i2;i++) {
  2343.         if (i==0) {
  2344.             u = ctx->Eval.MapGrid1u1;
  2345.         }
  2346.         else if (i==ctx->Eval.MapGrid1un) {
  2347.             u = ctx->Eval.MapGrid1u2;
  2348.         }
  2349.         else {
  2350.             u = i * du + ctx->Eval.MapGrid1u1;
  2351.         }
  2352.         gl_EvalCoord1f( ctx, u );
  2353.     }
  2354.     gl_End(ctx);
  2355. }
  2356.  
  2357.  
  2358.  
  2359. void gl_EvalMesh2( GLcontext* ctx, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
  2360. {
  2361.     GLint i, j;
  2362.     GLfloat u, du, v, dv, v1, v2;
  2363.  
  2364.     if (INSIDE_BEGIN_END(ctx)) {
  2365.         gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh2" );
  2366.         return;
  2367.     }
  2368.  
  2369.     du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
  2370.         / (GLfloat) ctx->Eval.MapGrid2un;
  2371.     dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
  2372.         / (GLfloat) ctx->Eval.MapGrid2vn;
  2373.  
  2374. #define I_TO_U( I, U )                          \
  2375.     if ((I)==0) {                   \
  2376.         U = ctx->Eval.MapGrid2u1;               \
  2377.     }                                       \
  2378.     else if ((I)==ctx->Eval.MapGrid2un) {   \
  2379.         U = ctx->Eval.MapGrid2u2;               \
  2380.     }                                       \
  2381.     else {                          \
  2382.         U = (I) * du + ctx->Eval.MapGrid2u1;\
  2383.     }
  2384.  
  2385. #define J_TO_V( J, V )                          \
  2386.     if ((J)==0) {                   \
  2387.         V = ctx->Eval.MapGrid2v1;               \
  2388.     }                                       \
  2389.     else if ((J)==ctx->Eval.MapGrid2vn) {   \
  2390.         V = ctx->Eval.MapGrid2v2;               \
  2391.     }                                       \
  2392.     else {                          \
  2393.         V = (J) * dv + ctx->Eval.MapGrid2v1;\
  2394.     }
  2395.  
  2396.     switch (mode) {
  2397.     case GL_POINT:
  2398.         gl_Begin( ctx, GL_POINTS );
  2399.         for (j=j1;j<=j2;j++) {
  2400.             J_TO_V( j, v );
  2401.             for (i=i1;i<=i2;i++) {
  2402.                 I_TO_U( i, u );
  2403.                 gl_EvalCoord2f( ctx, u, v );
  2404.             }
  2405.         }
  2406.         gl_End(ctx);
  2407.         break;
  2408.     case GL_LINE:
  2409.         for (j=j1;j<=j2;j++) {
  2410.             J_TO_V( j, v );
  2411.             gl_Begin( ctx, GL_LINE_STRIP );
  2412.             for (i=i1;i<=i2;i++) {
  2413.                 I_TO_U( i, u );
  2414.                 gl_EvalCoord2f( ctx, u, v );
  2415.             }
  2416.             gl_End(ctx);
  2417.         }
  2418.         for (i=i1;i<=i2;i++) {
  2419.             I_TO_U( i, u );
  2420.             gl_Begin( ctx, GL_LINE_STRIP );
  2421.             for (j=j1;j<=j2;j++) {
  2422.                 J_TO_V( j, v );
  2423.                 gl_EvalCoord2f( ctx, u, v );
  2424.             }
  2425.             gl_End(ctx);
  2426.         }
  2427.         break;
  2428.     case GL_FILL:
  2429.         for (j=j1;j<j2;j++) {
  2430.             /* NOTE: a quad strip can't be used because the four */
  2431.             /* can't be guaranteed to be coplanar! */
  2432.             gl_Begin( ctx, GL_TRIANGLE_STRIP );
  2433.             J_TO_V( j, v1 );
  2434.             J_TO_V( j+1, v2 );
  2435.             for (i=i1;i<=i2;i++) {
  2436.                 I_TO_U( i, u );
  2437.                 gl_EvalCoord2f( ctx, u, v1 );
  2438.                 gl_EvalCoord2f( ctx, u, v2 );
  2439.             }
  2440.             gl_End(ctx);
  2441.         }
  2442.         break;
  2443.     default:
  2444.         gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
  2445.         return;
  2446.     }
  2447.  
  2448. #undef I_TO_U
  2449. #undef J_TO_V
  2450. }
  2451.  
  2452.