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