Ignore:
Timestamp:
May 23, 2000, 10:41:28 PM (25 years ago)
Author:
jeroen
Message:

* empty log message *

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/opengl/mesa/eval.c

    r2962 r3598  
    1 /* $Id: eval.c,v 1.2 2000-03-01 18:49:28 jeroen Exp $ */
     1/* $Id: eval.c,v 1.3 2000-05-23 20:40:32 jeroen Exp $ */
    22
    33/*
    44 * Mesa 3-D graphics library
    5  * Version:  3.1
     5 * Version:  3.3
    66 *
    77 * Copyright (C) 1999  Brian Paul   All Rights Reserved.
    … …  
    4242#include "all.h"
    4343#else
    44 #ifndef XFree86Server
    45 #include <math.h>
    46 #include <stdlib.h>
    47 #include <string.h>
    48 #else
    49 #include "GL/xf86glx.h"
    50 #endif
     44#include "glheader.h"
    5145#include "types.h"
    5246#include "context.h"
    … …  
    5448#include "macros.h"
    5549#include "mmath.h"
     50#include "mem.h"
    5651#include "types.h"
    5752#include "vbcull.h"
    … …  
    8075  {
    8176     for (i = 1 ; i < MAX_EVAL_ORDER ; i++)
    82         inv_tab[i] = 1.0 / i;
     77        inv_tab[i] = 1.0 / i;
    8378  }
    8479
    … …  
    179174        /* Each control point is the point for parameter u on a */
    180175        /* curve defined by the control polygons in u-direction */
    181         bincoeff = uorder-1;
    182         s = 1.0-u;
    183 
    184         for(k=0; k<dim; k++)
    185           cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
    186 
    187         for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder;
     176        bincoeff = uorder-1;
     177        s = 1.0-u;
     178
     179        for(k=0; k<dim; k++)
     180          cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
     181
     182        for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder;
    188183            i++, poweru*=u, ucp +=uinc)
    189         {
    190           bincoeff *= uorder-i;
     184        {
     185          bincoeff *= uorder-i;
    191186          bincoeff *= inv_tab[i];
    192187
    193           for(k=0; k<dim; k++)
    194             cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
    195         }
     188          for(k=0; k<dim; k++)
     189            cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
     190        }
    196191      }
    197192
    … …  
    211206      for(i=0; i<uorder; i++, cn += uinc)
    212207      {
    213         /* For constant i all cn[i][j] (j=0..vorder) are located */
    214         /* on consecutive memory locations, so we can use        */
    215         /* horner_bezier_curve to compute the control points     */
    216 
    217         horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
     208        /* For constant i all cn[i][j] (j=0..vorder) are located */
     209        /* on consecutive memory locations, so we can use        */
     210        /* horner_bezier_curve to compute the control points     */
     211
     212        horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
    218213      }
    219214
    … …  
    266261      for(k=0; k<dim; k++)
    267262      {
    268         /* Derivative direction in u */
    269         du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
    270                  v*(CN(1,1,k) - CN(0,1,k));
    271 
    272         /* Derivative direction in v */
    273         dv[k] = us*(CN(0,1,k) - CN(0,0,k)) +
    274                  u*(CN(1,1,k) - CN(1,0,k));
    275 
    276         /* bilinear de Casteljau step */
     263        /* Derivative direction in u */
     264        du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
     265                 v*(CN(1,1,k) - CN(0,1,k));
     266
     267        /* Derivative direction in v */
     268        dv[k] = us*(CN(0,1,k) - CN(0,0,k)) +
     269                 u*(CN(1,1,k) - CN(1,0,k));
     270
     271        /* bilinear de Casteljau step */
    277272        out[k] =  us*(vs*CN(0,0,k) + v*CN(0,1,k)) +
    278                    u*(vs*CN(1,0,k) + v*CN(1,1,k));
     273                   u*(vs*CN(1,0,k) + v*CN(1,1,k));
    279274      }
    280275    }
    … …  
    283278      for(k=0; k<dim; k++)
    284279      {
    285         /* bilinear de Casteljau step */
    286         DCN(1,0) =    CN(1,0,k) -   CN(0,0,k);
    287         DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
    288 
    289         for(j=0; j<vorder-1; j++)
    290         {
    291           /* for the derivative in u */
    292           DCN(1,j+1) =    CN(1,j+1,k) -   CN(0,j+1,k);
    293           DCN(1,j)   = vs*DCN(1,j)    + v*DCN(1,j+1);
    294 
    295           /* for the `point' */
    296           DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
    297           DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
    298         }
    299 
    300         /* remaining linear de Casteljau steps until the second last step */
    301         for(h=minorder; h<vorder-1; h++)
    302           for(j=0; j<vorder-h; j++)
    303           {
    304             /* for the derivative in u */
    305             DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
    306 
    307             /* for the `point' */
    308             DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
    309           }
    310 
    311         /* derivative direction in v */
    312         dv[k] = DCN(0,1) - DCN(0,0);
    313 
    314         /* derivative direction in u */
    315         du[k] =   vs*DCN(1,0) + v*DCN(1,1);
    316 
    317         /* last linear de Casteljau step */
    318         out[k] =  vs*DCN(0,0) + v*DCN(0,1);
     280        /* bilinear de Casteljau step */
     281        DCN(1,0) =    CN(1,0,k) -   CN(0,0,k);
     282        DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
     283
     284        for(j=0; j<vorder-1; j++)
     285        {
     286          /* for the derivative in u */
     287          DCN(1,j+1) =    CN(1,j+1,k) -   CN(0,j+1,k);
     288          DCN(1,j)   = vs*DCN(1,j)    + v*DCN(1,j+1);
     289
     290          /* for the `point' */
     291          DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
     292          DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
     293        }
     294
     295        /* remaining linear de Casteljau steps until the second last step */
     296        for(h=minorder; h<vorder-1; h++)
     297          for(j=0; j<vorder-h; j++)
     298          {
     299            /* for the derivative in u */
     300            DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
     301
     302            /* for the `point' */
     303            DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
     304          }
     305
     306        /* derivative direction in v */
     307        dv[k] = DCN(0,1) - DCN(0,0);
     308
     309        /* derivative direction in u */
     310        du[k] =   vs*DCN(1,0) + v*DCN(1,1);
     311
     312        /* last linear de Casteljau step */
     313        out[k] =  vs*DCN(0,0) + v*DCN(0,1);
    319314      }
    320315    }
    … …  
    323318      for(k=0; k<dim; k++)
    324319      {
    325         /* bilinear de Casteljau step */
    326         DCN(0,1) =    CN(0,1,k) -   CN(0,0,k);
    327         DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
    328         for(i=0; i<uorder-1; i++)
    329         {
    330           /* for the derivative in v */
    331           DCN(i+1,1) =    CN(i+1,1,k) -   CN(i+1,0,k);
    332           DCN(i,1)   = us*DCN(i,1)    + u*DCN(i+1,1);
    333 
    334           /* for the `point' */
    335           DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
    336           DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
    337         }
    338 
    339         /* remaining linear de Casteljau steps until the second last step */
    340         for(h=minorder; h<uorder-1; h++)
    341           for(i=0; i<uorder-h; i++)
    342           {
    343             /* for the derivative in v */
    344             DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
    345 
    346             /* for the `point' */
    347             DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
    348           }
    349 
    350         /* derivative direction in u */
    351         du[k] = DCN(1,0) - DCN(0,0);
    352 
    353         /* derivative direction in v */
    354         dv[k] =   us*DCN(0,1) + u*DCN(1,1);
    355 
    356         /* last linear de Casteljau step */
    357         out[k] =  us*DCN(0,0) + u*DCN(1,0);
     320        /* bilinear de Casteljau step */
     321        DCN(0,1) =    CN(0,1,k) -   CN(0,0,k);
     322        DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
     323        for(i=0; i<uorder-1; i++)
     324        {
     325          /* for the derivative in v */
     326          DCN(i+1,1) =    CN(i+1,1,k) -   CN(i+1,0,k);
     327          DCN(i,1)   = us*DCN(i,1)    + u*DCN(i+1,1);
     328
     329          /* for the `point' */
     330          DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
     331          DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
     332        }
     333
     334        /* remaining linear de Casteljau steps until the second last step */
     335        for(h=minorder; h<uorder-1; h++)
     336          for(i=0; i<uorder-h; i++)
     337          {
     338            /* for the derivative in v */
     339            DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
     340
     341            /* for the `point' */
     342            DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
     343          }
     344
     345        /* derivative direction in u */
     346        du[k] = DCN(1,0) - DCN(0,0);
     347
     348        /* derivative direction in v */
     349        dv[k] =   us*DCN(0,1) + u*DCN(1,1);
     350
     351        /* last linear de Casteljau step */
     352        out[k] =  us*DCN(0,0) + u*DCN(1,0);
    358353      }
    359354    }
    … …  
    366361      for(i=0; i<uorder-1; i++)
    367362      {
    368         DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
    369         for(j=0; j<vorder-1; j++)
    370         {
    371           DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
    372           DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
    373         }
     363        DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
     364        for(j=0; j<vorder-1; j++)
     365        {
     366          DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
     367          DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
     368        }
    374369      }
    375370
    376371      /* remaining bilinear de Casteljau steps until the second last step */
    377372      for(h=2; h<minorder-1; h++)
    378         for(i=0; i<uorder-h; i++)
    379         {
    380           DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
    381           for(j=0; j<vorder-h; j++)
    382           {
    383             DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
    384             DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
    385           }
    386         }
     373        for(i=0; i<uorder-h; i++)
     374        {
     375          DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
     376          for(j=0; j<vorder-h; j++)
     377          {
     378            DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
     379            DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
     380          }
     381        }
    387382
    388383      /* derivative direction in u */
    389384      du[k] = vs*(DCN(1,0) - DCN(0,0)) +
    390                v*(DCN(1,1) - DCN(0,1));
     385               v*(DCN(1,1) - DCN(0,1));
    391386
    392387      /* derivative direction in v */
    393388      dv[k] = us*(DCN(0,1) - DCN(0,0)) +
    394                u*(DCN(1,1) - DCN(1,0));
     389               u*(DCN(1,1) - DCN(1,0));
    395390
    396391      /* last bilinear de Casteljau step */
    397392      out[k] =  us*(vs*DCN(0,0) + v*DCN(0,1)) +
    398                  u*(vs*DCN(1,0) + v*DCN(1,1));
     393                 u*(vs*DCN(1,0) + v*DCN(1,1));
    399394    }
    400395  }
    … …  
    406401      for(i=0; i<uorder-1; i++)
    407402      {
    408         DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
    409         for(j=0; j<vorder-1; j++)
    410         {
    411           DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
    412           DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
    413         }
     403        DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
     404        for(j=0; j<vorder-1; j++)
     405        {
     406          DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
     407          DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
     408        }
    414409      }
    415410
    416411      /* remaining bilinear de Casteljau steps until the second last step */
    417412      for(h=2; h<minorder-1; h++)
    418         for(i=0; i<uorder-h; i++)
    419         {
    420           DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
    421           for(j=0; j<vorder-h; j++)
    422           {
    423             DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
    424             DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
    425           }
    426         }
     413        for(i=0; i<uorder-h; i++)
     414        {
     415          DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
     416          for(j=0; j<vorder-h; j++)
     417          {
     418            DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
     419            DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
     420          }
     421        }
    427422
    428423      /* last bilinear de Casteljau step */
    … …  
    431426      for(j=0; j<vorder-1; j++)
    432427      {
    433         /* for the derivative in u */
    434         DCN(2,j+1) =    DCN(1,j+1) -    DCN(0,j+1);
    435         DCN(2,j)   = vs*DCN(2,j)    + v*DCN(2,j+1);
    436        
    437         /* for the `point' */
    438         DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
    439         DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
     428        /* for the derivative in u */
     429        DCN(2,j+1) =    DCN(1,j+1) -    DCN(0,j+1);
     430        DCN(2,j)   = vs*DCN(2,j)    + v*DCN(2,j+1);
     431
     432        /* for the `point' */
     433        DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
     434        DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
    440435      }
    441436
    442437      /* remaining linear de Casteljau steps until the second last step */
    443438      for(h=minorder; h<vorder-1; h++)
    444         for(j=0; j<vorder-h; j++)
    445         {
    446           /* for the derivative in u */
    447           DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
    448        
    449           /* for the `point' */
    450           DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
    451         }
     439        for(j=0; j<vorder-h; j++)
     440        {
     441          /* for the derivative in u */
     442          DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
     443
     444          /* for the `point' */
     445          DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
     446        }
    452447
    453448      /* derivative direction in v */
    … …  
    468463      for(i=0; i<uorder-1; i++)
    469464      {
    470         DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
    471         for(j=0; j<vorder-1; j++)
    472         {
    473           DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
    474           DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
    475         }
     465        DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
     466        for(j=0; j<vorder-1; j++)
     467        {
     468          DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
     469          DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
     470        }
    476471      }
    477472
    478473      /* remaining bilinear de Casteljau steps until the second last step */
    479474      for(h=2; h<minorder-1; h++)
    480         for(i=0; i<uorder-h; i++)
    481         {
    482           DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
    483           for(j=0; j<vorder-h; j++)
    484           {
    485             DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
    486             DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
    487           }
    488         }
     475        for(i=0; i<uorder-h; i++)
     476        {
     477          DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
     478          for(j=0; j<vorder-h; j++)
     479          {
     480            DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
     481            DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
     482          }
     483        }
    489484
    490485      /* last bilinear de Casteljau step */
    … …  
    493488      for(i=0; i<uorder-1; i++)
    494489      {
    495         /* for the derivative in v */
    496         DCN(i+1,2) =    DCN(i+1,1)  -   DCN(i+1,0);
    497         DCN(i,2)   = us*DCN(i,2)    + u*DCN(i+1,2);
    498        
    499         /* for the `point' */
    500         DCN(i+1,0) = vs*DCN(i+1,0)  + v*DCN(i+1,1);
    501         DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
     490        /* for the derivative in v */
     491        DCN(i+1,2) =    DCN(i+1,1)  -   DCN(i+1,0);
     492        DCN(i,2)   = us*DCN(i,2)    + u*DCN(i+1,2);
     493
     494        /* for the `point' */
     495        DCN(i+1,0) = vs*DCN(i+1,0)  + v*DCN(i+1,1);
     496        DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
    502497      }
    503498
    504499      /* remaining linear de Casteljau steps until the second last step */
    505500      for(h=minorder; h<uorder-1; h++)
    506         for(i=0; i<uorder-h; i++)
    507         {
    508           /* for the derivative in v */
    509           DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
    510        
    511           /* for the `point' */
    512           DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
    513         }
     501        for(i=0; i<uorder-h; i++)
     502        {
     503          /* for the derivative in v */
     504          DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
     505
     506          /* for the `point' */
     507          DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
     508        }
    514509
    515510      /* derivative direction in u */
    … …  
    530525 * Return the number of components per control point for any type of
    531526 * evaluator.  Return 0 if bad target.
     527 * See table 5.1 in the OpenGL 1.2 spec.
    532528 */
    533 
    534 static GLint components( GLenum target )
     529GLuint _mesa_evaluator_components( GLenum target )
    535530{
    536531   switch (target) {
    537       case GL_MAP1_VERTEX_3:            return 3;
    538       case GL_MAP1_VERTEX_4:            return 4;
    539       case GL_MAP1_INDEX:               return 1;
    540       case GL_MAP1_COLOR_4:             return 4;
    541       case GL_MAP1_NORMAL:              return 3;
    542       case GL_MAP1_TEXTURE_COORD_1:     return 1;
    543       case GL_MAP1_TEXTURE_COORD_2:     return 2;
    544       case GL_MAP1_TEXTURE_COORD_3:     return 3;
    545       case GL_MAP1_TEXTURE_COORD_4:     return 4;
    546       case GL_MAP2_VERTEX_3:            return 3;
    547       case GL_MAP2_VERTEX_4:            return 4;
    548       case GL_MAP2_INDEX:               return 1;
    549       case GL_MAP2_COLOR_4:             return 4;
    550       case GL_MAP2_NORMAL:              return 3;
    551       case GL_MAP2_TEXTURE_COORD_1:     return 1;
    552       case GL_MAP2_TEXTURE_COORD_2:     return 2;
    553       case GL_MAP2_TEXTURE_COORD_3:     return 3;
    554       case GL_MAP2_TEXTURE_COORD_4:     return 4;
    555       default:                          return 0;
     532      case GL_MAP1_VERTEX_3:            return 3;
     533      case GL_MAP1_VERTEX_4:            return 4;
     534      case GL_MAP1_INDEX:               return 1;
     535      case GL_MAP1_COLOR_4:             return 4;
     536      case GL_MAP1_NORMAL:              return 3;
     537      case GL_MAP1_TEXTURE_COORD_1:     return 1;
     538      case GL_MAP1_TEXTURE_COORD_2:     return 2;
     539      case GL_MAP1_TEXTURE_COORD_3:     return 3;
     540      case GL_MAP1_TEXTURE_COORD_4:     return 4;
     541      case GL_MAP2_VERTEX_3:            return 3;
     542      case GL_MAP2_VERTEX_4:            return 4;
     543      case GL_MAP2_INDEX:               return 1;
     544      case GL_MAP2_COLOR_4:             return 4;
     545      case GL_MAP2_NORMAL:              return 3;
     546      case GL_MAP2_TEXTURE_COORD_1:     return 1;
     547      case GL_MAP2_TEXTURE_COORD_2:     return 2;
     548      case GL_MAP2_TEXTURE_COORD_3:     return 3;
     549      case GL_MAP2_TEXTURE_COORD_4:     return 4;
     550      default:                          return 0;
    556551   }
    557552}
    … …  
    570565 *          of memory.
    571566 */
    572 GLfloat *gl_copy_map_points1f( GLenum target,
    573                                GLint ustride, GLint uorder,
     567GLfloat *gl_copy_map_points1f( GLenum target, GLint ustride, GLint uorder,
    574568                               const GLfloat *points )
    575569{
    576570   GLfloat *buffer, *p;
    577    GLint i, k, size = components(target);
     571   GLint i, k, size = _mesa_evaluator_components(target);
    578572
    579573   if (!points || size==0) {
    … …  
    585579   if(buffer)
    586580      for(i=0, p=buffer; i<uorder; i++, points+=ustride)
    587         for(k=0; k<size; k++)
    588           *p++ = points[k];
     581        for(k=0; k<size; k++)
     582          *p++ = points[k];
    589583
    590584   return buffer;
    … …  
    596590 * Same as above but convert doubles to floats.
    597591 */
    598 GLfloat *gl_copy_map_points1d( GLenum target,
    599                                 GLint ustride, GLint uorder,
    600                                 const GLdouble *points )
     592GLfloat *gl_copy_map_points1d( GLenum target, GLint ustride, GLint uorder,
     593                               const GLdouble *points )
    601594{
    602595   GLfloat *buffer, *p;
    603    GLint i, k, size = components(target);
     596   GLint i, k, size = _mesa_evaluator_components(target);
    604597
    605598   if (!points || size==0) {
    … …  
    611604   if(buffer)
    612605      for(i=0, p=buffer; i<uorder; i++, points+=ustride)
    613         for(k=0; k<size; k++)
    614           *p++ = (GLfloat) points[k];
     606        for(k=0; k<size; k++)
     607          *p++ = (GLfloat) points[k];
    615608
    616609   return buffer;
    … …  
    630623 */
    631624GLfloat *gl_copy_map_points2f( GLenum target,
    632                                 GLint ustride, GLint uorder,
    633                                 GLint vstride, GLint vorder,
    634                                 const GLfloat *points )
     625                               GLint ustride, GLint uorder,
     626                               GLint vstride, GLint vorder,
     627                               const GLfloat *points )
    635628{
    636629   GLfloat *buffer, *p;
    … …  
    638631   GLint uinc;
    639632
    640    size = components(target);
     633   size = _mesa_evaluator_components(target);
    641634
    642635   if (!points || size==0) {
    … …  
    660653   if (buffer)
    661654      for (i=0, p=buffer; i<uorder; i++, points += uinc)
    662         for (j=0; j<vorder; j++, points += vstride)
    663             for (k=0; k<size; k++)
    664                *p++ = points[k];
     655        for (j=0; j<vorder; j++, points += vstride)
     656            for (k=0; k<size; k++)
     657               *p++ = points[k];
    665658
    666659   return buffer;
    … …  
    681674   GLint uinc;
    682675
    683    size = components(target);
     676   size = _mesa_evaluator_components(target);
    684677
    685678   if (!points || size==0) {
    … …  
    703696   if (buffer)
    704697      for (i=0, p=buffer; i<uorder; i++, points += uinc)
    705         for (j=0; j<vorder; j++, points += vstride)
    706             for (k=0; k<size; k++)
    707                *p++ = (GLfloat) points[k];
     698        for (j=0; j<vorder; j++, points += vstride)
     699            for (k=0; k<size; k++)
     700               *p++ = (GLfloat) points[k];
    708701
    709702   return buffer;
    … …  
    711704
    712705
     706#if 00
    713707/*
    714708 * This function is called by the display list deallocator function to
    … …  
    726720      case GL_MAP1_VERTEX_4:
    727721         map1 = &ctx->EvalMap.Map1Vertex4;
    728         break;
     722        break;
    729723      case GL_MAP1_INDEX:
    730724         map1 = &ctx->EvalMap.Map1Index;
    … …  
    735729      case GL_MAP1_NORMAL:
    736730         map1 = &ctx->EvalMap.Map1Normal;
    737         break;
     731        break;
    738732      case GL_MAP1_TEXTURE_COORD_1:
    739733         map1 = &ctx->EvalMap.Map1Texture1;
    740         break;
     734        break;
    741735      case GL_MAP1_TEXTURE_COORD_2:
    742736         map1 = &ctx->EvalMap.Map1Texture2;
    743         break;
     737        break;
    744738      case GL_MAP1_TEXTURE_COORD_3:
    745739         map1 = &ctx->EvalMap.Map1Texture3;
    746         break;
     740        break;
    747741      case GL_MAP1_TEXTURE_COORD_4:
    748742         map1 = &ctx->EvalMap.Map1Texture4;
    749         break;
     743        break;
    750744      case GL_MAP2_VERTEX_3:
    751745         map2 = &ctx->EvalMap.Map2Vertex3;
    752         break;
     746        break;
    753747      case GL_MAP2_VERTEX_4:
    754748         map2 = &ctx->EvalMap.Map2Vertex4;
    755         break;
     749        break;
    756750      case GL_MAP2_INDEX:
    757751         map2 = &ctx->EvalMap.Map2Index;
    758         break;
     752        break;
    759753      case GL_MAP2_COLOR_4:
    760754         map2 = &ctx->EvalMap.Map2Color4;
    … …  
    762756      case GL_MAP2_NORMAL:
    763757         map2 = &ctx->EvalMap.Map2Normal;
    764         break;
     758        break;
    765759      case GL_MAP2_TEXTURE_COORD_1:
    766760         map2 = &ctx->EvalMap.Map2Texture1;
    767         break;
     761        break;
    768762      case GL_MAP2_TEXTURE_COORD_2:
    769763         map2 = &ctx->EvalMap.Map2Texture2;
    770         break;
     764        break;
    771765      case GL_MAP2_TEXTURE_COORD_3:
    772766         map2 = &ctx->EvalMap.Map2Texture3;
    773         break;
     767        break;
    774768      case GL_MAP2_TEXTURE_COORD_4:
    775769         map2 = &ctx->EvalMap.Map2Texture4;
    776         break;
     770        break;
    777771      default:
    778         gl_error( ctx, GL_INVALID_ENUM, "gl_free_control_points" );
     772        gl_error( ctx, GL_INVALID_ENUM, "gl_free_control_points" );
    779773         return;
    780774   }
    … …  
    806800
    807801}
     802#endif
    808803
    809804
    … …  
    815810
    816811/*
    817  * Note that the array of control points must be 'unpacked' at this time.
    818  * Input:  retain - if TRUE, this control point data is also in a display
    819  *                  list and can't be freed until the list is freed.
     812 * This does the work of glMap1[fd].
    820813 */
    821 void gl_Map1f( GLcontext* ctx, GLenum target,
    822                GLfloat u1, GLfloat u2, GLint stride,
    823                GLint order, const GLfloat *points, GLboolean retain )
    824 {
     814static void
     815map1(GLenum target, GLfloat u1, GLfloat u2, GLint ustride,
     816     GLint uorder, const GLvoid *points, GLenum type )
     817{
     818   GET_CURRENT_CONTEXT(ctx);
    825819   GLint k;
    826 
    827    if (!points) {
    828       gl_error( ctx, GL_OUT_OF_MEMORY, "glMap1f" );
    829       return;
    830    }
    831 
    832    /* may be a new stride after copying control points */
    833    stride = components( target );
     820   GLfloat *pnts;
    834821
    835822   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMap1");
    836823
    837    if (u1==u2) {
     824   ASSERT(type == GL_FLOAT || type == GL_DOUBLE);
     825
     826   if (u1 == u2) {
    838827      gl_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
    839828      return;
    840829   }
    841 
    842    if (order<1 || order>MAX_EVAL_ORDER) {
     830   if (uorder < 1 || uorder > MAX_EVAL_ORDER) {
    843831      gl_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
    844832      return;
    845833   }
    846 
    847    k = components( target );
    848    if (k==0) {
     834   if (!points) {
     835      gl_error( ctx, GL_INVALID_VALUE, "glMap1(points)" );
     836      return;
     837   }
     838
     839   k = _mesa_evaluator_components( target );
     840   if (k == 0) {
    849841      gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
    850842   }
    851843
    852    if (stride < k) {
     844   if (ustride < k) {
    853845      gl_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
    854846      return;
    855847   }
    856848
     849   /* make copy of the control points */
     850   if (type == GL_FLOAT)
     851      pnts = gl_copy_map_points1f(target, ustride, uorder, (GLfloat*) points);
     852   else
     853      pnts = gl_copy_map_points1d(target, ustride, uorder, (GLdouble*) points);
     854
    857855   switch (target) {
    858856      case GL_MAP1_VERTEX_3:
    859          ctx->EvalMap.Map1Vertex3.Order = order;
    860          ctx->EvalMap.Map1Vertex3.u1 = u1;
    861          ctx->EvalMap.Map1Vertex3.u2 = u2;
    862          ctx->EvalMap.Map1Vertex3.du = 1.0 / (u2 - u1);
    863          if (ctx->EvalMap.Map1Vertex3.Points
    864              && !ctx->EvalMap.Map1Vertex3.Retain) {
    865             FREE( ctx->EvalMap.Map1Vertex3.Points );
    866          }
    867          ctx->EvalMap.Map1Vertex3.Points = (GLfloat *) points;
    868          ctx->EvalMap.Map1Vertex3.Retain = retain;
    869          break;
     857         ctx->EvalMap.Map1Vertex3.Order = uorder;
     858         ctx->EvalMap.Map1Vertex3.u1 = u1;
     859         ctx->EvalMap.Map1Vertex3.u2 = u2;
     860         ctx->EvalMap.Map1Vertex3.du = 1.0 / (u2 - u1);
     861         if (ctx->EvalMap.Map1Vertex3.Points)
     862            FREE( ctx->EvalMap.Map1Vertex3.Points );
     863         ctx->EvalMap.Map1Vertex3.Points = pnts;
     864         break;
    870865      case GL_MAP1_VERTEX_4:
    871          ctx->EvalMap.Map1Vertex4.Order = order;
    872          ctx->EvalMap.Map1Vertex4.u1 = u1;
    873          ctx->EvalMap.Map1Vertex4.u2 = u2;
    874          ctx->EvalMap.Map1Vertex4.du = 1.0 / (u2 - u1);
    875          if (ctx->EvalMap.Map1Vertex4.Points
    876              && !ctx->EvalMap.Map1Vertex4.Retain) {
    877             FREE( ctx->EvalMap.Map1Vertex4.Points );
    878          }
    879          ctx->EvalMap.Map1Vertex4.Points = (GLfloat *) points;
    880          ctx->EvalMap.Map1Vertex4.Retain = retain;
    881          break;
     866         ctx->EvalMap.Map1Vertex4.Order = uorder;
     867         ctx->EvalMap.Map1Vertex4.u1 = u1;
     868         ctx->EvalMap.Map1Vertex4.u2 = u2;
     869         ctx->EvalMap.Map1Vertex4.du = 1.0 / (u2 - u1);
     870         if (ctx->EvalMap.Map1Vertex4.Points)
     871            FREE( ctx->EvalMap.Map1Vertex4.Points );
     872         ctx->EvalMap.Map1Vertex4.Points = pnts;
     873         break;
    882874      case GL_MAP1_INDEX:
    883          ctx->EvalMap.Map1Index.Order = order;
    884          ctx->EvalMap.Map1Index.u1 = u1;
    885          ctx->EvalMap.Map1Index.u2 = u2;
    886          ctx->EvalMap.Map1Index.du = 1.0 / (u2 - u1);
    887          if (ctx->EvalMap.Map1Index.Points
    888              && !ctx->EvalMap.Map1Index.Retain) {
    889             FREE( ctx->EvalMap.Map1Index.Points );
    890          }
    891          ctx->EvalMap.Map1Index.Points = (GLfloat *) points;
    892          ctx->EvalMap.Map1Index.Retain = retain;
    893          break;
     875         ctx->EvalMap.Map1Index.Order = uorder;
     876         ctx->EvalMap.Map1Index.u1 = u1;
     877         ctx->EvalMap.Map1Index.u2 = u2;
     878         ctx->EvalMap.Map1Index.du = 1.0 / (u2 - u1);
     879         if (ctx->EvalMap.Map1Index.Points)
     880            FREE( ctx->EvalMap.Map1Index.Points );
     881         ctx->EvalMap.Map1Index.Points = pnts;
     882         break;
    894883      case GL_MAP1_COLOR_4:
    895          ctx->EvalMap.Map1Color4.Order = order;
    896          ctx->EvalMap.Map1Color4.u1 = u1;
    897          ctx->EvalMap.Map1Color4.u2 = u2;
    898          ctx->EvalMap.Map1Color4.du = 1.0 / (u2 - u1);
    899          if (ctx->EvalMap.Map1Color4.Points
    900              && !ctx->EvalMap.Map1Color4.Retain) {
    901             FREE( ctx->EvalMap.Map1Color4.Points );
    902          }
    903          ctx->EvalMap.Map1Color4.Points = (GLfloat *) points;
    904          ctx->EvalMap.Map1Color4.Retain = retain;
    905          break;
     884         ctx->EvalMap.Map1Color4.Order = uorder;
     885         ctx->EvalMap.Map1Color4.u1 = u1;
     886         ctx->EvalMap.Map1Color4.u2 = u2;
     887         ctx->EvalMap.Map1Color4.du = 1.0 / (u2 - u1);
     888         if (ctx->EvalMap.Map1Color4.Points)
     889            FREE( ctx->EvalMap.Map1Color4.Points );
     890         ctx->EvalMap.Map1Color4.Points = pnts;
     891         break;
    906892      case GL_MAP1_NORMAL:
    907          ctx->EvalMap.Map1Normal.Order = order;
    908          ctx->EvalMap.Map1Normal.u1 = u1;
    909          ctx->EvalMap.Map1Normal.u2 = u2;
    910          ctx->EvalMap.Map1Normal.du = 1.0 / (u2 - u1);
    911          if (ctx->EvalMap.Map1Normal.Points
    912              && !ctx->EvalMap.Map1Normal.Retain) {
    913             FREE( ctx->EvalMap.Map1Normal.Points );
    914          }
    915          ctx->EvalMap.Map1Normal.Points = (GLfloat *) points;
    916          ctx->EvalMap.Map1Normal.Retain = retain;
    917          break;
     893         ctx->EvalMap.Map1Normal.Order = uorder;
     894         ctx->EvalMap.Map1Normal.u1 = u1;
     895         ctx->EvalMap.Map1Normal.u2 = u2;
     896         ctx->EvalMap.Map1Normal.du = 1.0 / (u2 - u1);
     897         if (ctx->EvalMap.Map1Normal.Points)
     898            FREE( ctx->EvalMap.Map1Normal.Points );
     899         ctx->EvalMap.Map1Normal.Points = pnts;
     900         break;
    918901      case GL_MAP1_TEXTURE_COORD_1:
    919          ctx->EvalMap.Map1Texture1.Order = order;
    920          ctx->EvalMap.Map1Texture1.u1 = u1;
    921          ctx->EvalMap.Map1Texture1.u2 = u2;
    922          ctx->EvalMap.Map1Texture1.du = 1.0 / (u2 - u1);
    923          if (ctx->EvalMap.Map1Texture1.Points
    924              && !ctx->EvalMap.Map1Texture1.Retain) {
    925             FREE( ctx->EvalMap.Map1Texture1.Points );
    926          }
    927          ctx->EvalMap.Map1Texture1.Points = (GLfloat *) points;
    928          ctx->EvalMap.Map1Texture1.Retain = retain;
    929          break;
     902         ctx->EvalMap.Map1Texture1.Order = uorder;
     903         ctx->EvalMap.Map1Texture1.u1 = u1;
     904         ctx->EvalMap.Map1Texture1.u2 = u2;
     905         ctx->EvalMap.Map1Texture1.du = 1.0 / (u2 - u1);
     906         if (ctx->EvalMap.Map1Texture1.Points)
     907            FREE( ctx->EvalMap.Map1Texture1.Points );
     908         ctx->EvalMap.Map1Texture1.Points = pnts;
     909         break;
    930910      case GL_MAP1_TEXTURE_COORD_2:
    931          ctx->EvalMap.Map1Texture2.Order = order;
    932          ctx->EvalMap.Map1Texture2.u1 = u1;
    933          ctx->EvalMap.Map1Texture2.u2 = u2;
    934          ctx->EvalMap.Map1Texture2.du = 1.0 / (u2 - u1);
    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;
     911         ctx->EvalMap.Map1Texture2.Order = uorder;
     912         ctx->EvalMap.Map1Texture2.u1 = u1;
     913         ctx->EvalMap.Map1Texture2.u2 = u2;
     914         ctx->EvalMap.Map1Texture2.du = 1.0 / (u2 - u1);
     915         if (ctx->EvalMap.Map1Texture2.Points)
     916            FREE( ctx->EvalMap.Map1Texture2.Points );
     917         ctx->EvalMap.Map1Texture2.Points = pnts;
     918         break;
    942919      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          ctx->EvalMap.Map1Texture3.du = 1.0 / (u2 - u1);
    947          if (ctx->EvalMap.Map1Texture3.Points
    948              && !ctx->EvalMap.Map1Texture3.Retain) {
    949             FREE( ctx->EvalMap.Map1Texture3.Points );
    950          }
    951          ctx->EvalMap.Map1Texture3.Points = (GLfloat *) points;
    952          ctx->EvalMap.Map1Texture3.Retain = retain;
    953          break;
     920         ctx->EvalMap.Map1Texture3.Order = uorder;
     921         ctx->EvalMap.Map1Texture3.u1 = u1;
     922         ctx->EvalMap.Map1Texture3.u2 = u2;
     923         ctx->EvalMap.Map1Texture3.du = 1.0 / (u2 - u1);
     924         if (ctx->EvalMap.Map1Texture3.Points)
     925            FREE( ctx->EvalMap.Map1Texture3.Points );
     926         ctx->EvalMap.Map1Texture3.Points = pnts;
     927         break;
    954928      case GL_MAP1_TEXTURE_COORD_4:
    955          ctx->EvalMap.Map1Texture4.Order = order;
    956          ctx->EvalMap.Map1Texture4.u1 = u1;
    957          ctx->EvalMap.Map1Texture4.u2 = u2;
    958          ctx->EvalMap.Map1Texture4.du = 1.0 / (u2 - u1);
    959          if (ctx->EvalMap.Map1Texture4.Points
    960              && !ctx->EvalMap.Map1Texture4.Retain) {
    961             FREE( ctx->EvalMap.Map1Texture4.Points );
    962          }
    963          ctx->EvalMap.Map1Texture4.Points = (GLfloat *) points;
    964          ctx->EvalMap.Map1Texture4.Retain = retain;
    965          break;
     929         ctx->EvalMap.Map1Texture4.Order = uorder;
     930         ctx->EvalMap.Map1Texture4.u1 = u1;
     931         ctx->EvalMap.Map1Texture4.u2 = u2;
     932         ctx->EvalMap.Map1Texture4.du = 1.0 / (u2 - u1);
     933         if (ctx->EvalMap.Map1Texture4.Points)
     934            FREE( ctx->EvalMap.Map1Texture4.Points );
     935         ctx->EvalMap.Map1Texture4.Points = pnts;
     936         break;
    966937      default:
    967938         gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
    … …  
    969940}
    970941
    971 
    972 
    973 
    974 /*
    975  * Note that the array of control points must be 'unpacked' at this time.
    976  * Input:  retain - if TRUE, this control point data is also in a display
    977  *                  list and can't be freed until the list is freed.
    978  */
    979 void gl_Map2f( GLcontext* ctx, GLenum target,
    980               GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
    981               GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
    982               const GLfloat *points, GLboolean retain )
    983 {
     942void
     943_mesa_Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
     944             GLint order, const GLfloat *points )
     945{
     946   map1(target, u1, u2, stride, order, points, GL_FLOAT);
     947}
     948
     949
     950void
     951_mesa_Map1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
     952             GLint order, const GLdouble *points )
     953{
     954   map1(target, u1, u2, stride, order, points, GL_DOUBLE);
     955}
     956
     957
     958static void
     959map2( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
     960      GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
     961      const GLvoid *points, GLenum type )
     962{
     963   GET_CURRENT_CONTEXT(ctx);
    984964   GLint k;
     965   GLfloat *pnts;
    985966
    986967   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMap2");
    … …  
    1006987   }
    1007988
    1008    k = components( target );
     989   k = _mesa_evaluator_components( target );
    1009990   if (k==0) {
    1010991      gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
    … …  
    10201001   }
    10211002
     1003   /* make copy of the control points */
     1004   if (type == GL_FLOAT)
     1005      pnts = gl_copy_map_points2f(target, ustride, uorder,
     1006                                  vstride, vorder, (GLfloat*) points);
     1007   else
     1008      pnts = gl_copy_map_points2d(target, ustride, uorder,
     1009                                  vstride, vorder, (GLdouble*) points);
     1010
    10221011   switch (target) {
    10231012      case GL_MAP2_VERTEX_3:
    10241013         ctx->EvalMap.Map2Vertex3.Uorder = uorder;
    1025         ctx->EvalMap.Map2Vertex3.u1 = u1;
    1026         ctx->EvalMap.Map2Vertex3.u2 = u2;
    1027         ctx->EvalMap.Map2Vertex3.du = 1.0 / (u2 - u1);
     1014        ctx->EvalMap.Map2Vertex3.u1 = u1;
     1015        ctx->EvalMap.Map2Vertex3.u2 = u2;
     1016        ctx->EvalMap.Map2Vertex3.du = 1.0 / (u2 - u1);
    10281017         ctx->EvalMap.Map2Vertex3.Vorder = vorder;
    1029          ctx->EvalMap.Map2Vertex3.v1 = v1;
    1030          ctx->EvalMap.Map2Vertex3.v2 = v2;
    1031          ctx->EvalMap.Map2Vertex3.dv = 1.0 / (v2 - v1);
    1032          if (ctx->EvalMap.Map2Vertex3.Points
    1033              && !ctx->EvalMap.Map2Vertex3.Retain) {
    1034             FREE( ctx->EvalMap.Map2Vertex3.Points );
    1035          }
    1036          ctx->EvalMap.Map2Vertex3.Retain = retain;
    1037          ctx->EvalMap.Map2Vertex3.Points = (GLfloat *) points;
    1038          break;
     1018         ctx->EvalMap.Map2Vertex3.v1 = v1;
     1019         ctx->EvalMap.Map2Vertex3.v2 = v2;
     1020         ctx->EvalMap.Map2Vertex3.dv = 1.0 / (v2 - v1);
     1021         if (ctx->EvalMap.Map2Vertex3.Points)
     1022            FREE( ctx->EvalMap.Map2Vertex3.Points );
     1023         ctx->EvalMap.Map2Vertex3.Points = pnts;
     1024         break;
    10391025      case GL_MAP2_VERTEX_4:
    10401026         ctx->EvalMap.Map2Vertex4.Uorder = uorder;
    1041         ctx->EvalMap.Map2Vertex4.u1 = u1;
    1042         ctx->EvalMap.Map2Vertex4.u2 = u2;
    1043         ctx->EvalMap.Map2Vertex4.du = 1.0 / (u2 - u1);
     1027        ctx->EvalMap.Map2Vertex4.u1 = u1;
     1028        ctx->EvalMap.Map2Vertex4.u2 = u2;
     1029        ctx->EvalMap.Map2Vertex4.du = 1.0 / (u2 - u1);
    10441030         ctx->EvalMap.Map2Vertex4.Vorder = vorder;
    1045          ctx->EvalMap.Map2Vertex4.v1 = v1;
    1046          ctx->EvalMap.Map2Vertex4.v2 = v2;
    1047          ctx->EvalMap.Map2Vertex4.dv = 1.0 / (v2 - v1);
    1048          if (ctx->EvalMap.Map2Vertex4.Points
    1049              && !ctx->EvalMap.Map2Vertex4.Retain) {
    1050             FREE( ctx->EvalMap.Map2Vertex4.Points );
    1051          }
    1052          ctx->EvalMap.Map2Vertex4.Points = (GLfloat *) points;
    1053          ctx->EvalMap.Map2Vertex4.Retain = retain;
    1054          break;
     1031         ctx->EvalMap.Map2Vertex4.v1 = v1;
     1032         ctx->EvalMap.Map2Vertex4.v2 = v2;
     1033         ctx->EvalMap.Map2Vertex4.dv = 1.0 / (v2 - v1);
     1034         if (ctx->EvalMap.Map2Vertex4.Points)
     1035            FREE( ctx->EvalMap.Map2Vertex4.Points );
     1036         ctx->EvalMap.Map2Vertex4.Points = pnts;
     1037         break;
    10551038      case GL_MAP2_INDEX:
    10561039         ctx->EvalMap.Map2Index.Uorder = uorder;
    1057         ctx->EvalMap.Map2Index.u1 = u1;
    1058         ctx->EvalMap.Map2Index.u2 = u2;
    1059         ctx->EvalMap.Map2Index.du = 1.0 / (u2 - u1);
     1040        ctx->EvalMap.Map2Index.u1 = u1;
     1041        ctx->EvalMap.Map2Index.u2 = u2;
     1042        ctx->EvalMap.Map2Index.du = 1.0 / (u2 - u1);
    10601043         ctx->EvalMap.Map2Index.Vorder = vorder;
    1061          ctx->EvalMap.Map2Index.v1 = v1;
    1062          ctx->EvalMap.Map2Index.v2 = v2;
    1063          ctx->EvalMap.Map2Index.dv = 1.0 / (v2 - v1);
    1064          if (ctx->EvalMap.Map2Index.Points
    1065              && !ctx->EvalMap.Map2Index.Retain) {
    1066             FREE( ctx->EvalMap.Map2Index.Points );
    1067          }
    1068          ctx->EvalMap.Map2Index.Retain = retain;
    1069          ctx->EvalMap.Map2Index.Points = (GLfloat *) points;
    1070          break;
     1044         ctx->EvalMap.Map2Index.v1 = v1;
     1045         ctx->EvalMap.Map2Index.v2 = v2;
     1046         ctx->EvalMap.Map2Index.dv = 1.0 / (v2 - v1);
     1047         if (ctx->EvalMap.Map2Index.Points)
     1048            FREE( ctx->EvalMap.Map2Index.Points );
     1049         ctx->EvalMap.Map2Index.Points = pnts;
     1050         break;
    10711051      case GL_MAP2_COLOR_4:
    10721052         ctx->EvalMap.Map2Color4.Uorder = uorder;
    1073         ctx->EvalMap.Map2Color4.u1 = u1;
    1074         ctx->EvalMap.Map2Color4.u2 = u2;
    1075         ctx->EvalMap.Map2Color4.du = 1.0 / (u2 - u1);
     1053        ctx->EvalMap.Map2Color4.u1 = u1;
     1054        ctx->EvalMap.Map2Color4.u2 = u2;
     1055        ctx->EvalMap.Map2Color4.du = 1.0 / (u2 - u1);
    10761056         ctx->EvalMap.Map2Color4.Vorder = vorder;
    1077          ctx->EvalMap.Map2Color4.v1 = v1;
    1078          ctx->EvalMap.Map2Color4.v2 = v2;
    1079          ctx->EvalMap.Map2Color4.dv = 1.0 / (v2 - v1);
    1080          if (ctx->EvalMap.Map2Color4.Points
    1081              && !ctx->EvalMap.Map2Color4.Retain) {
    1082             FREE( ctx->EvalMap.Map2Color4.Points );
    1083          }
    1084          ctx->EvalMap.Map2Color4.Retain = retain;
    1085          ctx->EvalMap.Map2Color4.Points = (GLfloat *) points;
    1086          break;
     1057         ctx->EvalMap.Map2Color4.v1 = v1;
     1058         ctx->EvalMap.Map2Color4.v2 = v2;
     1059         ctx->EvalMap.Map2Color4.dv = 1.0 / (v2 - v1);
     1060         if (ctx->EvalMap.Map2Color4.Points)
     1061            FREE( ctx->EvalMap.Map2Color4.Points );
     1062         ctx->EvalMap.Map2Color4.Points = pnts;
     1063         break;
    10871064      case GL_MAP2_NORMAL:
    10881065         ctx->EvalMap.Map2Normal.Uorder = uorder;
    1089         ctx->EvalMap.Map2Normal.u1 = u1;
    1090         ctx->EvalMap.Map2Normal.u2 = u2;
    1091         ctx->EvalMap.Map2Normal.du = 1.0 / (u2 - u1);
     1066        ctx->EvalMap.Map2Normal.u1 = u1;
     1067        ctx->EvalMap.Map2Normal.u2 = u2;
     1068        ctx->EvalMap.Map2Normal.du = 1.0 / (u2 - u1);
    10921069         ctx->EvalMap.Map2Normal.Vorder = vorder;
    1093          ctx->EvalMap.Map2Normal.v1 = v1;
    1094          ctx->EvalMap.Map2Normal.v2 = v2;
    1095          ctx->EvalMap.Map2Normal.dv = 1.0 / (v2 - v1);
    1096          if (ctx->EvalMap.Map2Normal.Points
    1097              && !ctx->EvalMap.Map2Normal.Retain) {
    1098             FREE( ctx->EvalMap.Map2Normal.Points );
    1099          }
    1100          ctx->EvalMap.Map2Normal.Retain = retain;
    1101          ctx->EvalMap.Map2Normal.Points = (GLfloat *) points;
    1102          break;
     1070         ctx->EvalMap.Map2Normal.v1 = v1;
     1071         ctx->EvalMap.Map2Normal.v2 = v2;
     1072         ctx->EvalMap.Map2Normal.dv = 1.0 / (v2 - v1);
     1073         if (ctx->EvalMap.Map2Normal.Points)
     1074            FREE( ctx->EvalMap.Map2Normal.Points );
     1075         ctx->EvalMap.Map2Normal.Points = pnts;
     1076         break;
    11031077      case GL_MAP2_TEXTURE_COORD_1:
    11041078         ctx->EvalMap.Map2Texture1.Uorder = uorder;
    1105         ctx->EvalMap.Map2Texture1.u1 = u1;
    1106         ctx->EvalMap.Map2Texture1.u2 = u2;
    1107         ctx->EvalMap.Map2Texture1.du = 1.0 / (u2 - u1);
     1079        ctx->EvalMap.Map2Texture1.u1 = u1;
     1080        ctx->EvalMap.Map2Texture1.u2 = u2;
     1081        ctx->EvalMap.Map2Texture1.du = 1.0 / (u2 - u1);
    11081082         ctx->EvalMap.Map2Texture1.Vorder = vorder;
    1109          ctx->EvalMap.Map2Texture1.v1 = v1;
    1110          ctx->EvalMap.Map2Texture1.v2 = v2;
    1111          ctx->EvalMap.Map2Texture1.dv = 1.0 / (v2 - v1);
    1112          if (ctx->EvalMap.Map2Texture1.Points
    1113              && !ctx->EvalMap.Map2Texture1.Retain) {
    1114             FREE( ctx->EvalMap.Map2Texture1.Points );
    1115          }
    1116          ctx->EvalMap.Map2Texture1.Retain = retain;
    1117          ctx->EvalMap.Map2Texture1.Points = (GLfloat *) points;
    1118          break;
     1083         ctx->EvalMap.Map2Texture1.v1 = v1;
     1084         ctx->EvalMap.Map2Texture1.v2 = v2;
     1085         ctx->EvalMap.Map2Texture1.dv = 1.0 / (v2 - v1);
     1086         if (ctx->EvalMap.Map2Texture1.Points)
     1087            FREE( ctx->EvalMap.Map2Texture1.Points );
     1088         ctx->EvalMap.Map2Texture1.Points = pnts;
     1089         break;
    11191090      case GL_MAP2_TEXTURE_COORD_2:
    11201091         ctx->EvalMap.Map2Texture2.Uorder = uorder;
    1121         ctx->EvalMap.Map2Texture2.u1 = u1;
    1122         ctx->EvalMap.Map2Texture2.u2 = u2;
    1123         ctx->EvalMap.Map2Texture2.du = 1.0 / (u2 - u1);
     1092        ctx->EvalMap.Map2Texture2.u1 = u1;
     1093        ctx->EvalMap.Map2Texture2.u2 = u2;
     1094        ctx->EvalMap.Map2Texture2.du = 1.0 / (u2 - u1);
    11241095         ctx->EvalMap.Map2Texture2.Vorder = vorder;
    1125          ctx->EvalMap.Map2Texture2.v1 = v1;
    1126          ctx->EvalMap.Map2Texture2.v2 = v2;
    1127          ctx->EvalMap.Map2Texture2.dv = 1.0 / (v2 - v1);
    1128          if (ctx->EvalMap.Map2Texture2.Points
    1129              && !ctx->EvalMap.Map2Texture2.Retain) {
    1130             FREE( ctx->EvalMap.Map2Texture2.Points );
    1131          }
    1132          ctx->EvalMap.Map2Texture2.Retain = retain;
    1133          ctx->EvalMap.Map2Texture2.Points = (GLfloat *) points;
    1134          break;
     1096         ctx->EvalMap.Map2Texture2.v1 = v1;
     1097         ctx->EvalMap.Map2Texture2.v2 = v2;
     1098         ctx->EvalMap.Map2Texture2.dv = 1.0 / (v2 - v1);
     1099         if (ctx->EvalMap.Map2Texture2.Points)
     1100            FREE( ctx->EvalMap.Map2Texture2.Points );
     1101         ctx->EvalMap.Map2Texture2.Points = pnts;
     1102         break;
    11351103      case GL_MAP2_TEXTURE_COORD_3:
    11361104         ctx->EvalMap.Map2Texture3.Uorder = uorder;
    1137         ctx->EvalMap.Map2Texture3.u1 = u1;
    1138         ctx->EvalMap.Map2Texture3.u2 = u2;
    1139         ctx->EvalMap.Map2Texture3.du = 1.0 / (u2 - u1);
     1105        ctx->EvalMap.Map2Texture3.u1 = u1;
     1106        ctx->EvalMap.Map2Texture3.u2 = u2;
     1107        ctx->EvalMap.Map2Texture3.du = 1.0 / (u2 - u1);
    11401108         ctx->EvalMap.Map2Texture3.Vorder = vorder;
    1141          ctx->EvalMap.Map2Texture3.v1 = v1;
    1142          ctx->EvalMap.Map2Texture3.v2 = v2;
    1143          ctx->EvalMap.Map2Texture3.dv = 1.0 / (v2 - v1);
    1144          if (ctx->EvalMap.Map2Texture3.Points
    1145              && !ctx->EvalMap.Map2Texture3.Retain) {
    1146             FREE( ctx->EvalMap.Map2Texture3.Points );
    1147          }
    1148          ctx->EvalMap.Map2Texture3.Retain = retain;
    1149          ctx->EvalMap.Map2Texture3.Points = (GLfloat *) points;
    1150          break;
     1109         ctx->EvalMap.Map2Texture3.v1 = v1;
     1110         ctx->EvalMap.Map2Texture3.v2 = v2;
     1111         ctx->EvalMap.Map2Texture3.dv = 1.0 / (v2 - v1);
     1112         if (ctx->EvalMap.Map2Texture3.Points)
     1113            FREE( ctx->EvalMap.Map2Texture3.Points );
     1114         ctx->EvalMap.Map2Texture3.Points = pnts;
     1115         break;
    11511116      case GL_MAP2_TEXTURE_COORD_4:
    11521117         ctx->EvalMap.Map2Texture4.Uorder = uorder;
    1153         ctx->EvalMap.Map2Texture4.u1 = u1;
    1154         ctx->EvalMap.Map2Texture4.u2 = u2;
    1155         ctx->EvalMap.Map2Texture4.du = 1.0 / (u2 - u1);
     1118        ctx->EvalMap.Map2Texture4.u1 = u1;
     1119        ctx->EvalMap.Map2Texture4.u2 = u2;
     1120        ctx->EvalMap.Map2Texture4.du = 1.0 / (u2 - u1);
    11561121         ctx->EvalMap.Map2Texture4.Vorder = vorder;
    1157          ctx->EvalMap.Map2Texture4.v1 = v1;
    1158          ctx->EvalMap.Map2Texture4.v2 = v2;
    1159          ctx->EvalMap.Map2Texture4.dv = 1.0 / (v2 - v1);
    1160          if (ctx->EvalMap.Map2Texture4.Points
    1161              && !ctx->EvalMap.Map2Texture4.Retain) {
    1162             FREE( ctx->EvalMap.Map2Texture4.Points );
    1163          }
    1164          ctx->EvalMap.Map2Texture4.Retain = retain;
    1165          ctx->EvalMap.Map2Texture4.Points = (GLfloat *) points;
    1166          break;
     1122         ctx->EvalMap.Map2Texture4.v1 = v1;
     1123         ctx->EvalMap.Map2Texture4.v2 = v2;
     1124         ctx->EvalMap.Map2Texture4.dv = 1.0 / (v2 - v1);
     1125         if (ctx->EvalMap.Map2Texture4.Points)
     1126            FREE( ctx->EvalMap.Map2Texture4.Points );
     1127         ctx->EvalMap.Map2Texture4.Points = pnts;
     1128         break;
    11671129      default:
    11681130         gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
    … …  
    11711133
    11721134
    1173 
    1174 
    1175 
    1176 void gl_GetMapdv( GLcontext* ctx, GLenum target, GLenum query, GLdouble *v )
    1177 {
     1135void
     1136_mesa_Map2f( GLenum target,
     1137             GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
     1138             GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
     1139             const GLfloat *points)
     1140{
     1141   map2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
     1142        points, GL_FLOAT);
     1143}
     1144
     1145
     1146void
     1147_mesa_Map2d( GLenum target,
     1148             GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
     1149             GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
     1150             const GLdouble *points )
     1151{
     1152   map2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
     1153        points, GL_DOUBLE);
     1154}
     1155
     1156
     1157
     1158void
     1159_mesa_GetMapdv( GLenum target, GLenum query, GLdouble *v )
     1160{
     1161   GET_CURRENT_CONTEXT(ctx);
    11781162   GLint i, n;
    11791163   GLfloat *data;
    … …  
    11811165   switch (query) {
    11821166      case GL_COEFF:
    1183         switch (target) {
    1184             case GL_MAP1_COLOR_4:
    1185                data = ctx->EvalMap.Map1Color4.Points;
    1186                n = ctx->EvalMap.Map1Color4.Order * 4;
    1187                break;
    1188             case GL_MAP1_INDEX:
    1189                data = ctx->EvalMap.Map1Index.Points;
    1190                n = ctx->EvalMap.Map1Index.Order;
    1191                break;
    1192             case GL_MAP1_NORMAL:
    1193                data = ctx->EvalMap.Map1Normal.Points;
    1194                n = ctx->EvalMap.Map1Normal.Order * 3;
    1195                break;
    1196             case GL_MAP1_TEXTURE_COORD_1:
    1197                data = ctx->EvalMap.Map1Texture1.Points;
    1198                n = ctx->EvalMap.Map1Texture1.Order * 1;
    1199                break;
    1200             case GL_MAP1_TEXTURE_COORD_2:
    1201                data = ctx->EvalMap.Map1Texture2.Points;
    1202                n = ctx->EvalMap.Map1Texture2.Order * 2;
    1203                break;
    1204             case GL_MAP1_TEXTURE_COORD_3:
    1205                data = ctx->EvalMap.Map1Texture3.Points;
    1206                n = ctx->EvalMap.Map1Texture3.Order * 3;
    1207                break;
    1208             case GL_MAP1_TEXTURE_COORD_4:
    1209                data = ctx->EvalMap.Map1Texture4.Points;
    1210                n = ctx->EvalMap.Map1Texture4.Order * 4;
    1211                break;
    1212             case GL_MAP1_VERTEX_3:
    1213                data = ctx->EvalMap.Map1Vertex3.Points;
    1214                n = ctx->EvalMap.Map1Vertex3.Order * 3;
    1215                break;
    1216             case GL_MAP1_VERTEX_4:
    1217                data = ctx->EvalMap.Map1Vertex4.Points;
    1218                n = ctx->EvalMap.Map1Vertex4.Order * 4;
    1219                break;
    1220             case GL_MAP2_COLOR_4:
    1221                data = ctx->EvalMap.Map2Color4.Points;
    1222                n = ctx->EvalMap.Map2Color4.Uorder
     1167        switch (target) {
     1168            case GL_MAP1_COLOR_4:
     1169               data = ctx->EvalMap.Map1Color4.Points;
     1170               n = ctx->EvalMap.Map1Color4.Order * 4;
     1171               break;
     1172            case GL_MAP1_INDEX:
     1173               data = ctx->EvalMap.Map1Index.Points;
     1174               n = ctx->EvalMap.Map1Index.Order;
     1175               break;
     1176            case GL_MAP1_NORMAL:
     1177               data = ctx->EvalMap.Map1Normal.Points;
     1178               n = ctx->EvalMap.Map1Normal.Order * 3;
     1179               break;
     1180            case GL_MAP1_TEXTURE_COORD_1:
     1181               data = ctx->EvalMap.Map1Texture1.Points;
     1182               n = ctx->EvalMap.Map1Texture1.Order * 1;
     1183               break;
     1184            case GL_MAP1_TEXTURE_COORD_2:
     1185               data = ctx->EvalMap.Map1Texture2.Points;
     1186               n = ctx->EvalMap.Map1Texture2.Order * 2;
     1187               break;
     1188            case GL_MAP1_TEXTURE_COORD_3:
     1189               data = ctx->EvalMap.Map1Texture3.Points;
     1190               n = ctx->EvalMap.Map1Texture3.Order * 3;
     1191               break;
     1192            case GL_MAP1_TEXTURE_COORD_4:
     1193               data = ctx->EvalMap.Map1Texture4.Points;
     1194               n = ctx->EvalMap.Map1Texture4.Order * 4;
     1195               break;
     1196            case GL_MAP1_VERTEX_3:
     1197               data = ctx->EvalMap.Map1Vertex3.Points;
     1198               n = ctx->EvalMap.Map1Vertex3.Order * 3;
     1199               break;
     1200            case GL_MAP1_VERTEX_4:
     1201               data = ctx->EvalMap.Map1Vertex4.Points;
     1202               n = ctx->EvalMap.Map1Vertex4.Order * 4;
     1203               break;
     1204            case GL_MAP2_COLOR_4:
     1205               data = ctx->EvalMap.Map2Color4.Points;
     1206               n = ctx->EvalMap.Map2Color4.Uorder
    12231207                 * ctx->EvalMap.Map2Color4.Vorder * 4;
    1224                break;
    1225             case GL_MAP2_INDEX:
    1226                data = ctx->EvalMap.Map2Index.Points;
    1227                n = ctx->EvalMap.Map2Index.Uorder
     1208               break;
     1209            case GL_MAP2_INDEX:
     1210               data = ctx->EvalMap.Map2Index.Points;
     1211               n = ctx->EvalMap.Map2Index.Uorder
    12281212                 * ctx->EvalMap.Map2Index.Vorder;
    1229                break;
    1230             case GL_MAP2_NORMAL:
    1231                data = ctx->EvalMap.Map2Normal.Points;
    1232                n = ctx->EvalMap.Map2Normal.Uorder
     1213               break;
     1214            case GL_MAP2_NORMAL:
     1215               data = ctx->EvalMap.Map2Normal.Points;
     1216               n = ctx->EvalMap.Map2Normal.Uorder
    12331217                 * ctx->EvalMap.Map2Normal.Vorder * 3;
    1234                break;
    1235             case GL_MAP2_TEXTURE_COORD_1:
    1236                data = ctx->EvalMap.Map2Texture1.Points;
    1237                n = ctx->EvalMap.Map2Texture1.Uorder
     1218               break;
     1219            case GL_MAP2_TEXTURE_COORD_1:
     1220               data = ctx->EvalMap.Map2Texture1.Points;
     1221               n = ctx->EvalMap.Map2Texture1.Uorder
    12381222                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
    1239                break;
    1240             case GL_MAP2_TEXTURE_COORD_2:
    1241                data = ctx->EvalMap.Map2Texture2.Points;
    1242                n = ctx->EvalMap.Map2Texture2.Uorder
     1223               break;
     1224            case GL_MAP2_TEXTURE_COORD_2:
     1225               data = ctx->EvalMap.Map2Texture2.Points;
     1226               n = ctx->EvalMap.Map2Texture2.Uorder
    12431227                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
    1244                break;
    1245             case GL_MAP2_TEXTURE_COORD_3:
    1246                data = ctx->EvalMap.Map2Texture3.Points;
    1247                n = ctx->EvalMap.Map2Texture3.Uorder
     1228               break;
     1229            case GL_MAP2_TEXTURE_COORD_3:
     1230               data = ctx->EvalMap.Map2Texture3.Points;
     1231               n = ctx->EvalMap.Map2Texture3.Uorder
    12481232                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
    1249                break;
    1250             case GL_MAP2_TEXTURE_COORD_4:
    1251                data = ctx->EvalMap.Map2Texture4.Points;
    1252                n = ctx->EvalMap.Map2Texture4.Uorder
     1233               break;
     1234            case GL_MAP2_TEXTURE_COORD_4:
     1235               data = ctx->EvalMap.Map2Texture4.Points;
     1236               n = ctx->EvalMap.Map2Texture4.Uorder
    12531237                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
    1254                break;
    1255             case GL_MAP2_VERTEX_3:
    1256                data = ctx->EvalMap.Map2Vertex3.Points;
    1257                n = ctx->EvalMap.Map2Vertex3.Uorder
     1238               break;
     1239            case GL_MAP2_VERTEX_3:
     1240               data = ctx->EvalMap.Map2Vertex3.Points;
     1241               n = ctx->EvalMap.Map2Vertex3.Uorder
    12581242                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
    1259                break;
    1260             case GL_MAP2_VERTEX_4:
    1261                data = ctx->EvalMap.Map2Vertex4.Points;
    1262                n = ctx->EvalMap.Map2Vertex4.Uorder
     1243               break;
     1244            case GL_MAP2_VERTEX_4:
     1245               data = ctx->EvalMap.Map2Vertex4.Points;
     1246               n = ctx->EvalMap.Map2Vertex4.Uorder
    12631247                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
    1264                break;
    1265             default:
    1266                gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
    1267                return;
    1268         }
    1269         if (data) {
    1270             for (i=0;i<n;i++) {
    1271                v[i] = data[i];
    1272             }
    1273         }
     1248               break;
     1249            default:
     1250               gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
     1251               return;
     1252        }
     1253        if (data) {
     1254            for (i=0;i<n;i++) {
     1255               v[i] = data[i];
     1256            }
     1257        }
    12741258         break;
    12751259      case GL_ORDER:
    1276         switch (target) {
    1277             case GL_MAP1_COLOR_4:
    1278                *v = ctx->EvalMap.Map1Color4.Order;
    1279                break;
    1280             case GL_MAP1_INDEX:
    1281                *v = ctx->EvalMap.Map1Index.Order;
    1282                break;
    1283             case GL_MAP1_NORMAL:
    1284                *v = ctx->EvalMap.Map1Normal.Order;
    1285                break;
    1286             case GL_MAP1_TEXTURE_COORD_1:
    1287                *v = ctx->EvalMap.Map1Texture1.Order;
    1288                break;
    1289             case GL_MAP1_TEXTURE_COORD_2:
    1290                *v = ctx->EvalMap.Map1Texture2.Order;
    1291                break;
    1292             case GL_MAP1_TEXTURE_COORD_3:
    1293                *v = ctx->EvalMap.Map1Texture3.Order;
    1294                break;
    1295             case GL_MAP1_TEXTURE_COORD_4:
    1296                *v = ctx->EvalMap.Map1Texture4.Order;
    1297                break;
    1298             case GL_MAP1_VERTEX_3:
    1299                *v = ctx->EvalMap.Map1Vertex3.Order;
    1300                break;
    1301             case GL_MAP1_VERTEX_4:
    1302                *v = ctx->EvalMap.Map1Vertex4.Order;
    1303                break;
    1304             case GL_MAP2_COLOR_4:
    1305                v[0] = ctx->EvalMap.Map2Color4.Uorder;
    1306                v[1] = ctx->EvalMap.Map2Color4.Vorder;
    1307                break;
    1308             case GL_MAP2_INDEX:
    1309                v[0] = ctx->EvalMap.Map2Index.Uorder;
    1310                v[1] = ctx->EvalMap.Map2Index.Vorder;
    1311                break;
    1312             case GL_MAP2_NORMAL:
    1313                v[0] = ctx->EvalMap.Map2Normal.Uorder;
    1314                v[1] = ctx->EvalMap.Map2Normal.Vorder;
    1315                break;
    1316             case GL_MAP2_TEXTURE_COORD_1:
    1317                v[0] = ctx->EvalMap.Map2Texture1.Uorder;
    1318                v[1] = ctx->EvalMap.Map2Texture1.Vorder;
    1319                break;
    1320             case GL_MAP2_TEXTURE_COORD_2:
    1321                v[0] = ctx->EvalMap.Map2Texture2.Uorder;
    1322                v[1] = ctx->EvalMap.Map2Texture2.Vorder;
    1323                break;
    1324             case GL_MAP2_TEXTURE_COORD_3:
    1325                v[0] = ctx->EvalMap.Map2Texture3.Uorder;
    1326                v[1] = ctx->EvalMap.Map2Texture3.Vorder;
    1327                break;
    1328             case GL_MAP2_TEXTURE_COORD_4:
    1329                v[0] = ctx->EvalMap.Map2Texture4.Uorder;
    1330                v[1] = ctx->EvalMap.Map2Texture4.Vorder;
    1331                break;
    1332             case GL_MAP2_VERTEX_3:
    1333                v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
    1334                v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
    1335                break;
    1336             case GL_MAP2_VERTEX_4:
    1337                v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
    1338                v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
    1339                break;
    1340             default:
    1341                gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
    1342                return;
    1343         }
     1260        switch (target) {
     1261            case GL_MAP1_COLOR_4:
     1262               *v = ctx->EvalMap.Map1Color4.Order;
     1263               break;
     1264            case GL_MAP1_INDEX:
     1265               *v = ctx->EvalMap.Map1Index.Order;
     1266               break;
     1267            case GL_MAP1_NORMAL:
     1268               *v = ctx->EvalMap.Map1Normal.Order;
     1269               break;
     1270            case GL_MAP1_TEXTURE_COORD_1:
     1271               *v = ctx->EvalMap.Map1Texture1.Order;
     1272               break;
     1273            case GL_MAP1_TEXTURE_COORD_2:
     1274               *v = ctx->EvalMap.Map1Texture2.Order;
     1275               break;
     1276            case GL_MAP1_TEXTURE_COORD_3:
     1277               *v = ctx->EvalMap.Map1Texture3.Order;
     1278               break;
     1279            case GL_MAP1_TEXTURE_COORD_4:
     1280               *v = ctx->EvalMap.Map1Texture4.Order;
     1281               break;
     1282            case GL_MAP1_VERTEX_3:
     1283               *v = ctx->EvalMap.Map1Vertex3.Order;
     1284               break;
     1285            case GL_MAP1_VERTEX_4:
     1286               *v = ctx->EvalMap.Map1Vertex4.Order;
     1287               break;
     1288            case GL_MAP2_COLOR_4:
     1289               v[0] = ctx->EvalMap.Map2Color4.Uorder;
     1290               v[1] = ctx->EvalMap.Map2Color4.Vorder;
     1291               break;
     1292            case GL_MAP2_INDEX:
     1293               v[0] = ctx->EvalMap.Map2Index.Uorder;
     1294               v[1] = ctx->EvalMap.Map2Index.Vorder;
     1295               break;
     1296            case GL_MAP2_NORMAL:
     1297               v[0] = ctx->EvalMap.Map2Normal.Uorder;
     1298               v[1] = ctx->EvalMap.Map2Normal.Vorder;
     1299               break;
     1300            case GL_MAP2_TEXTURE_COORD_1:
     1301               v[0] = ctx->EvalMap.Map2Texture1.Uorder;
     1302               v[1] = ctx->EvalMap.Map2Texture1.Vorder;
     1303               break;
     1304            case GL_MAP2_TEXTURE_COORD_2:
     1305               v[0] = ctx->EvalMap.Map2Texture2.Uorder;
     1306               v[1] = ctx->EvalMap.Map2Texture2.Vorder;
     1307               break;
     1308            case GL_MAP2_TEXTURE_COORD_3:
     1309               v[0] = ctx->EvalMap.Map2Texture3.Uorder;
     1310               v[1] = ctx->EvalMap.Map2Texture3.Vorder;
     1311               break;
     1312            case GL_MAP2_TEXTURE_COORD_4:
     1313               v[0] = ctx->EvalMap.Map2Texture4.Uorder;
     1314               v[1] = ctx->EvalMap.Map2Texture4.Vorder;
     1315               break;
     1316            case GL_MAP2_VERTEX_3:
     1317               v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
     1318               v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
     1319               break;
     1320            case GL_MAP2_VERTEX_4:
     1321               v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
     1322               v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
     1323               break;
     1324            default:
     1325               gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
     1326               return;
     1327        }
    13441328         break;
    13451329      case GL_DOMAIN:
    1346         switch (target) {
    1347             case GL_MAP1_COLOR_4:
    1348                v[0] = ctx->EvalMap.Map1Color4.u1;
    1349                v[1] = ctx->EvalMap.Map1Color4.u2;
    1350                break;
    1351             case GL_MAP1_INDEX:
    1352                v[0] = ctx->EvalMap.Map1Index.u1;
    1353                v[1] = ctx->EvalMap.Map1Index.u2;
    1354                break;
    1355             case GL_MAP1_NORMAL:
    1356                v[0] = ctx->EvalMap.Map1Normal.u1;
    1357                v[1] = ctx->EvalMap.Map1Normal.u2;
    1358                break;
    1359             case GL_MAP1_TEXTURE_COORD_1:
    1360                v[0] = ctx->EvalMap.Map1Texture1.u1;
    1361                v[1] = ctx->EvalMap.Map1Texture1.u2;
    1362                break;
    1363             case GL_MAP1_TEXTURE_COORD_2:
    1364                v[0] = ctx->EvalMap.Map1Texture2.u1;
    1365                v[1] = ctx->EvalMap.Map1Texture2.u2;
    1366                break;
    1367             case GL_MAP1_TEXTURE_COORD_3:
    1368                v[0] = ctx->EvalMap.Map1Texture3.u1;
    1369                v[1] = ctx->EvalMap.Map1Texture3.u2;
    1370                break;
    1371             case GL_MAP1_TEXTURE_COORD_4:
    1372                v[0] = ctx->EvalMap.Map1Texture4.u1;
    1373                v[1] = ctx->EvalMap.Map1Texture4.u2;
    1374                break;
    1375             case GL_MAP1_VERTEX_3:
    1376                v[0] = ctx->EvalMap.Map1Vertex3.u1;
    1377                v[1] = ctx->EvalMap.Map1Vertex3.u2;
    1378                break;
    1379             case GL_MAP1_VERTEX_4:
    1380                v[0] = ctx->EvalMap.Map1Vertex4.u1;
    1381                v[1] = ctx->EvalMap.Map1Vertex4.u2;
    1382                break;
    1383             case GL_MAP2_COLOR_4:
    1384                v[0] = ctx->EvalMap.Map2Color4.u1;
    1385                v[1] = ctx->EvalMap.Map2Color4.u2;
    1386                v[2] = ctx->EvalMap.Map2Color4.v1;
    1387                v[3] = ctx->EvalMap.Map2Color4.v2;
    1388                break;
    1389             case GL_MAP2_INDEX:
    1390                v[0] = ctx->EvalMap.Map2Index.u1;
    1391                v[1] = ctx->EvalMap.Map2Index.u2;
    1392                v[2] = ctx->EvalMap.Map2Index.v1;
    1393                v[3] = ctx->EvalMap.Map2Index.v2;
    1394                break;
    1395             case GL_MAP2_NORMAL:
    1396                v[0] = ctx->EvalMap.Map2Normal.u1;
    1397                v[1] = ctx->EvalMap.Map2Normal.u2;
    1398                v[2] = ctx->EvalMap.Map2Normal.v1;
    1399                v[3] = ctx->EvalMap.Map2Normal.v2;
    1400                break;
    1401             case GL_MAP2_TEXTURE_COORD_1:
    1402                v[0] = ctx->EvalMap.Map2Texture1.u1;
    1403                v[1] = ctx->EvalMap.Map2Texture1.u2;
    1404                v[2] = ctx->EvalMap.Map2Texture1.v1;
    1405                v[3] = ctx->EvalMap.Map2Texture1.v2;
    1406                break;
    1407             case GL_MAP2_TEXTURE_COORD_2:
    1408                v[0] = ctx->EvalMap.Map2Texture2.u1;
    1409                v[1] = ctx->EvalMap.Map2Texture2.u2;
    1410                v[2] = ctx->EvalMap.Map2Texture2.v1;
    1411                v[3] = ctx->EvalMap.Map2Texture2.v2;
    1412                break;
    1413             case GL_MAP2_TEXTURE_COORD_3:
    1414                v[0] = ctx->EvalMap.Map2Texture3.u1;
    1415                v[1] = ctx->EvalMap.Map2Texture3.u2;
    1416                v[2] = ctx->EvalMap.Map2Texture3.v1;
    1417                v[3] = ctx->EvalMap.Map2Texture3.v2;
    1418                break;
    1419             case GL_MAP2_TEXTURE_COORD_4:
    1420                v[0] = ctx->EvalMap.Map2Texture4.u1;
    1421                v[1] = ctx->EvalMap.Map2Texture4.u2;
    1422                v[2] = ctx->EvalMap.Map2Texture4.v1;
    1423                v[3] = ctx->EvalMap.Map2Texture4.v2;
    1424                break;
    1425             case GL_MAP2_VERTEX_3:
    1426                v[0] = ctx->EvalMap.Map2Vertex3.u1;
    1427                v[1] = ctx->EvalMap.Map2Vertex3.u2;
    1428                v[2] = ctx->EvalMap.Map2Vertex3.v1;
    1429                v[3] = ctx->EvalMap.Map2Vertex3.v2;
    1430                break;
    1431             case GL_MAP2_VERTEX_4:
    1432                v[0] = ctx->EvalMap.Map2Vertex4.u1;
    1433                v[1] = ctx->EvalMap.Map2Vertex4.u2;
    1434                v[2] = ctx->EvalMap.Map2Vertex4.v1;
    1435                v[3] = ctx->EvalMap.Map2Vertex4.v2;
    1436                break;
    1437             default:
    1438                gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
    1439         }
     1330        switch (target) {
     1331            case GL_MAP1_COLOR_4:
     1332               v[0] = ctx->EvalMap.Map1Color4.u1;
     1333               v[1] = ctx->EvalMap.Map1Color4.u2;
     1334               break;
     1335            case GL_MAP1_INDEX:
     1336               v[0] = ctx->EvalMap.Map1Index.u1;
     1337               v[1] = ctx->EvalMap.Map1Index.u2;
     1338               break;
     1339            case GL_MAP1_NORMAL:
     1340               v[0] = ctx->EvalMap.Map1Normal.u1;
     1341               v[1] = ctx->EvalMap.Map1Normal.u2;
     1342               break;
     1343            case GL_MAP1_TEXTURE_COORD_1:
     1344               v[0] = ctx->EvalMap.Map1Texture1.u1;
     1345               v[1] = ctx->EvalMap.Map1Texture1.u2;
     1346               break;
     1347            case GL_MAP1_TEXTURE_COORD_2:
     1348               v[0] = ctx->EvalMap.Map1Texture2.u1;
     1349               v[1] = ctx->EvalMap.Map1Texture2.u2;
     1350               break;
     1351            case GL_MAP1_TEXTURE_COORD_3:
     1352               v[0] = ctx->EvalMap.Map1Texture3.u1;
     1353               v[1] = ctx->EvalMap.Map1Texture3.u2;
     1354               break;
     1355            case GL_MAP1_TEXTURE_COORD_4:
     1356               v[0] = ctx->EvalMap.Map1Texture4.u1;
     1357               v[1] = ctx->EvalMap.Map1Texture4.u2;
     1358               break;
     1359            case GL_MAP1_VERTEX_3:
     1360               v[0] = ctx->EvalMap.Map1Vertex3.u1;
     1361               v[1] = ctx->EvalMap.Map1Vertex3.u2;
     1362               break;
     1363            case GL_MAP1_VERTEX_4:
     1364               v[0] = ctx->EvalMap.Map1Vertex4.u1;
     1365               v[1] = ctx->EvalMap.Map1Vertex4.u2;
     1366               break;
     1367            case GL_MAP2_COLOR_4:
     1368               v[0] = ctx->EvalMap.Map2Color4.u1;
     1369               v[1] = ctx->EvalMap.Map2Color4.u2;
     1370               v[2] = ctx->EvalMap.Map2Color4.v1;
     1371               v[3] = ctx->EvalMap.Map2Color4.v2;
     1372               break;
     1373            case GL_MAP2_INDEX:
     1374               v[0] = ctx->EvalMap.Map2Index.u1;
     1375               v[1] = ctx->EvalMap.Map2Index.u2;
     1376               v[2] = ctx->EvalMap.Map2Index.v1;
     1377               v[3] = ctx->EvalMap.Map2Index.v2;
     1378               break;
     1379            case GL_MAP2_NORMAL:
     1380               v[0] = ctx->EvalMap.Map2Normal.u1;
     1381               v[1] = ctx->EvalMap.Map2Normal.u2;
     1382               v[2] = ctx->EvalMap.Map2Normal.v1;
     1383               v[3] = ctx->EvalMap.Map2Normal.v2;
     1384               break;
     1385            case GL_MAP2_TEXTURE_COORD_1:
     1386               v[0] = ctx->EvalMap.Map2Texture1.u1;
     1387               v[1] = ctx->EvalMap.Map2Texture1.u2;
     1388               v[2] = ctx->EvalMap.Map2Texture1.v1;
     1389               v[3] = ctx->EvalMap.Map2Texture1.v2;
     1390               break;
     1391            case GL_MAP2_TEXTURE_COORD_2:
     1392               v[0] = ctx->EvalMap.Map2Texture2.u1;
     1393               v[1] = ctx->EvalMap.Map2Texture2.u2;
     1394               v[2] = ctx->EvalMap.Map2Texture2.v1;
     1395               v[3] = ctx->EvalMap.Map2Texture2.v2;
     1396               break;
     1397            case GL_MAP2_TEXTURE_COORD_3:
     1398               v[0] = ctx->EvalMap.Map2Texture3.u1;
     1399               v[1] = ctx->EvalMap.Map2Texture3.u2;
     1400               v[2] = ctx->EvalMap.Map2Texture3.v1;
     1401               v[3] = ctx->EvalMap.Map2Texture3.v2;
     1402               break;
     1403            case GL_MAP2_TEXTURE_COORD_4:
     1404               v[0] = ctx->EvalMap.Map2Texture4.u1;
     1405               v[1] = ctx->EvalMap.Map2Texture4.u2;
     1406               v[2] = ctx->EvalMap.Map2Texture4.v1;
     1407               v[3] = ctx->EvalMap.Map2Texture4.v2;
     1408               break;
     1409            case GL_MAP2_VERTEX_3:
     1410               v[0] = ctx->EvalMap.Map2Vertex3.u1;
     1411               v[1] = ctx->EvalMap.Map2Vertex3.u2;
     1412               v[2] = ctx->EvalMap.Map2Vertex3.v1;
     1413               v[3] = ctx->EvalMap.Map2Vertex3.v2;
     1414               break;
     1415            case GL_MAP2_VERTEX_4:
     1416               v[0] = ctx->EvalMap.Map2Vertex4.u1;
     1417               v[1] = ctx->EvalMap.Map2Vertex4.u2;
     1418               v[2] = ctx->EvalMap.Map2Vertex4.v1;
     1419               v[3] = ctx->EvalMap.Map2Vertex4.v2;
     1420               break;
     1421            default:
     1422               gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
     1423        }
    14401424         break;
    14411425      default:
    … …  
    14451429
    14461430
    1447 void gl_GetMapfv( GLcontext* ctx, GLenum target, GLenum query, GLfloat *v )
    1448 {
     1431void
     1432_mesa_GetMapfv( GLenum target, GLenum query, GLfloat *v )
     1433{
     1434   GET_CURRENT_CONTEXT(ctx);
    14491435   GLint i, n;
    14501436   GLfloat *data;
    … …  
    14521438   switch (query) {
    14531439      case GL_COEFF:
    1454         switch (target) {
    1455             case GL_MAP1_COLOR_4:
    1456                data = ctx->EvalMap.Map1Color4.Points;
    1457                n = ctx->EvalMap.Map1Color4.Order * 4;
    1458                break;
    1459             case GL_MAP1_INDEX:
    1460                data = ctx->EvalMap.Map1Index.Points;
    1461                n = ctx->EvalMap.Map1Index.Order;
    1462                break;
    1463             case GL_MAP1_NORMAL:
    1464                data = ctx->EvalMap.Map1Normal.Points;
    1465                n = ctx->EvalMap.Map1Normal.Order * 3;
    1466                break;
    1467             case GL_MAP1_TEXTURE_COORD_1:
    1468                data = ctx->EvalMap.Map1Texture1.Points;
    1469                n = ctx->EvalMap.Map1Texture1.Order * 1;
    1470                break;
    1471             case GL_MAP1_TEXTURE_COORD_2:
    1472                data = ctx->EvalMap.Map1Texture2.Points;
    1473                n = ctx->EvalMap.Map1Texture2.Order * 2;
    1474                break;
    1475             case GL_MAP1_TEXTURE_COORD_3:
    1476                data = ctx->EvalMap.Map1Texture3.Points;
    1477                n = ctx->EvalMap.Map1Texture3.Order * 3;
    1478                break;
    1479             case GL_MAP1_TEXTURE_COORD_4:
    1480                data = ctx->EvalMap.Map1Texture4.Points;
    1481                n = ctx->EvalMap.Map1Texture4.Order * 4;
    1482                break;
    1483             case GL_MAP1_VERTEX_3:
    1484                data = ctx->EvalMap.Map1Vertex3.Points;
    1485                n = ctx->EvalMap.Map1Vertex3.Order * 3;
    1486                break;
    1487             case GL_MAP1_VERTEX_4:
    1488                data = ctx->EvalMap.Map1Vertex4.Points;
    1489                n = ctx->EvalMap.Map1Vertex4.Order * 4;
    1490                break;
    1491             case GL_MAP2_COLOR_4:
    1492                data = ctx->EvalMap.Map2Color4.Points;
    1493                n = ctx->EvalMap.Map2Color4.Uorder
     1440        switch (target) {
     1441            case GL_MAP1_COLOR_4:
     1442               data = ctx->EvalMap.Map1Color4.Points;
     1443               n = ctx->EvalMap.Map1Color4.Order * 4;
     1444               break;
     1445            case GL_MAP1_INDEX:
     1446               data = ctx->EvalMap.Map1Index.Points;
     1447               n = ctx->EvalMap.Map1Index.Order;
     1448               break;
     1449            case GL_MAP1_NORMAL:
     1450               data = ctx->EvalMap.Map1Normal.Points;
     1451               n = ctx->EvalMap.Map1Normal.Order * 3;
     1452               break;
     1453            case GL_MAP1_TEXTURE_COORD_1:
     1454               data = ctx->EvalMap.Map1Texture1.Points;
     1455               n = ctx->EvalMap.Map1Texture1.Order * 1;
     1456               break;
     1457            case GL_MAP1_TEXTURE_COORD_2:
     1458               data = ctx->EvalMap.Map1Texture2.Points;
     1459               n = ctx->EvalMap.Map1Texture2.Order * 2;
     1460               break;
     1461            case GL_MAP1_TEXTURE_COORD_3:
     1462               data = ctx->EvalMap.Map1Texture3.Points;
     1463               n = ctx->EvalMap.Map1Texture3.Order * 3;
     1464               break;
     1465            case GL_MAP1_TEXTURE_COORD_4:
     1466               data = ctx->EvalMap.Map1Texture4.Points;
     1467               n = ctx->EvalMap.Map1Texture4.Order * 4;
     1468               break;
     1469            case GL_MAP1_VERTEX_3:
     1470               data = ctx->EvalMap.Map1Vertex3.Points;
     1471               n = ctx->EvalMap.Map1Vertex3.Order * 3;
     1472               break;
     1473            case GL_MAP1_VERTEX_4:
     1474               data = ctx->EvalMap.Map1Vertex4.Points;
     1475               n = ctx->EvalMap.Map1Vertex4.Order * 4;
     1476               break;
     1477            case GL_MAP2_COLOR_4:
     1478               data = ctx->EvalMap.Map2Color4.Points;
     1479               n = ctx->EvalMap.Map2Color4.Uorder
    14941480                 * ctx->EvalMap.Map2Color4.Vorder * 4;
    1495                break;
    1496             case GL_MAP2_INDEX:
    1497                data = ctx->EvalMap.Map2Index.Points;
    1498                n = ctx->EvalMap.Map2Index.Uorder
     1481               break;
     1482            case GL_MAP2_INDEX:
     1483               data = ctx->EvalMap.Map2Index.Points;
     1484               n = ctx->EvalMap.Map2Index.Uorder
    14991485                 * ctx->EvalMap.Map2Index.Vorder;
    1500                break;
    1501             case GL_MAP2_NORMAL:
    1502                data = ctx->EvalMap.Map2Normal.Points;
    1503                n = ctx->EvalMap.Map2Normal.Uorder
     1486               break;
     1487            case GL_MAP2_NORMAL:
     1488               data = ctx->EvalMap.Map2Normal.Points;
     1489               n = ctx->EvalMap.Map2Normal.Uorder
    15041490                 * ctx->EvalMap.Map2Normal.Vorder * 3;
    1505                break;
    1506             case GL_MAP2_TEXTURE_COORD_1:
    1507                data = ctx->EvalMap.Map2Texture1.Points;
    1508                n = ctx->EvalMap.Map2Texture1.Uorder
     1491               break;
     1492            case GL_MAP2_TEXTURE_COORD_1:
     1493               data = ctx->EvalMap.Map2Texture1.Points;
     1494               n = ctx->EvalMap.Map2Texture1.Uorder
    15091495                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
    1510                break;
    1511             case GL_MAP2_TEXTURE_COORD_2:
    1512                data = ctx->EvalMap.Map2Texture2.Points;
    1513                n = ctx->EvalMap.Map2Texture2.Uorder
     1496               break;
     1497            case GL_MAP2_TEXTURE_COORD_2:
     1498               data = ctx->EvalMap.Map2Texture2.Points;
     1499               n = ctx->EvalMap.Map2Texture2.Uorder
    15141500                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
    1515                break;
    1516             case GL_MAP2_TEXTURE_COORD_3:
    1517                data = ctx->EvalMap.Map2Texture3.Points;
    1518                n = ctx->EvalMap.Map2Texture3.Uorder
     1501               break;
     1502            case GL_MAP2_TEXTURE_COORD_3:
     1503               data = ctx->EvalMap.Map2Texture3.Points;
     1504               n = ctx->EvalMap.Map2Texture3.Uorder
    15191505                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
    1520                break;
    1521             case GL_MAP2_TEXTURE_COORD_4:
    1522                data = ctx->EvalMap.Map2Texture4.Points;
    1523                n = ctx->EvalMap.Map2Texture4.Uorder
     1506               break;
     1507            case GL_MAP2_TEXTURE_COORD_4:
     1508               data = ctx->EvalMap.Map2Texture4.Points;
     1509               n = ctx->EvalMap.Map2Texture4.Uorder
    15241510                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
    1525                break;
    1526             case GL_MAP2_VERTEX_3:
    1527                data = ctx->EvalMap.Map2Vertex3.Points;
    1528                n = ctx->EvalMap.Map2Vertex3.Uorder
     1511               break;
     1512            case GL_MAP2_VERTEX_3:
     1513               data = ctx->EvalMap.Map2Vertex3.Points;
     1514               n = ctx->EvalMap.Map2Vertex3.Uorder
    15291515                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
    1530                break;
    1531             case GL_MAP2_VERTEX_4:
    1532                data = ctx->EvalMap.Map2Vertex4.Points;
    1533                n = ctx->EvalMap.Map2Vertex4.Uorder
     1516               break;
     1517            case GL_MAP2_VERTEX_4:
     1518               data = ctx->EvalMap.Map2Vertex4.Points;
     1519               n = ctx->EvalMap.Map2Vertex4.Uorder
    15341520                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
    1535                break;
    1536             default:
    1537                gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
    1538                return;
    1539         }
    1540         if (data) {
    1541             for (i=0;i<n;i++) {
    1542                v[i] = data[i];
    1543             }
    1544         }
     1521               break;
     1522            default:
     1523               gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
     1524               return;
     1525        }
     1526        if (data) {
     1527            for (i=0;i<n;i++) {
     1528               v[i] = data[i];
     1529            }
     1530        }
    15451531         break;
    15461532      case GL_ORDER:
    1547         switch (target) {
    1548             case GL_MAP1_COLOR_4:
    1549                *v = ctx->EvalMap.Map1Color4.Order;
    1550                break;
    1551             case GL_MAP1_INDEX:
    1552                *v = ctx->EvalMap.Map1Index.Order;
    1553                break;
    1554             case GL_MAP1_NORMAL:
    1555                *v = ctx->EvalMap.Map1Normal.Order;
    1556                break;
    1557             case GL_MAP1_TEXTURE_COORD_1:
    1558                *v = ctx->EvalMap.Map1Texture1.Order;
    1559                break;
    1560             case GL_MAP1_TEXTURE_COORD_2:
    1561                *v = ctx->EvalMap.Map1Texture2.Order;
    1562                break;
    1563             case GL_MAP1_TEXTURE_COORD_3:
    1564                *v = ctx->EvalMap.Map1Texture3.Order;
    1565                break;
    1566             case GL_MAP1_TEXTURE_COORD_4:
    1567                *v = ctx->EvalMap.Map1Texture4.Order;
    1568                break;
    1569             case GL_MAP1_VERTEX_3:
    1570                *v = ctx->EvalMap.Map1Vertex3.Order;
    1571                break;
    1572             case GL_MAP1_VERTEX_4:
    1573                *v = ctx->EvalMap.Map1Vertex4.Order;
    1574                break;
    1575             case GL_MAP2_COLOR_4:
    1576                v[0] = ctx->EvalMap.Map2Color4.Uorder;
    1577                v[1] = ctx->EvalMap.Map2Color4.Vorder;
    1578                break;
    1579             case GL_MAP2_INDEX:
    1580                v[0] = ctx->EvalMap.Map2Index.Uorder;
    1581                v[1] = ctx->EvalMap.Map2Index.Vorder;
    1582                break;
    1583             case GL_MAP2_NORMAL:
    1584                v[0] = ctx->EvalMap.Map2Normal.Uorder;
    1585                v[1] = ctx->EvalMap.Map2Normal.Vorder;
    1586                break;
    1587             case GL_MAP2_TEXTURE_COORD_1:
    1588                v[0] = ctx->EvalMap.Map2Texture1.Uorder;
    1589                v[1] = ctx->EvalMap.Map2Texture1.Vorder;
    1590                break;
    1591             case GL_MAP2_TEXTURE_COORD_2:
    1592                v[0] = ctx->EvalMap.Map2Texture2.Uorder;
    1593                v[1] = ctx->EvalMap.Map2Texture2.Vorder;
    1594                break;
    1595             case GL_MAP2_TEXTURE_COORD_3:
    1596                v[0] = ctx->EvalMap.Map2Texture3.Uorder;
    1597                v[1] = ctx->EvalMap.Map2Texture3.Vorder;
    1598                break;
    1599             case GL_MAP2_TEXTURE_COORD_4:
    1600                v[0] = ctx->EvalMap.Map2Texture4.Uorder;
    1601                v[1] = ctx->EvalMap.Map2Texture4.Vorder;
    1602                break;
    1603             case GL_MAP2_VERTEX_3:
    1604                v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
    1605                v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
    1606                break;
    1607             case GL_MAP2_VERTEX_4:
    1608                v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
    1609                v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
    1610                break;
    1611             default:
    1612                gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
    1613                return;
    1614         }
     1533        switch (target) {
     1534            case GL_MAP1_COLOR_4:
     1535               *v = ctx->EvalMap.Map1Color4.Order;
     1536               break;
     1537            case GL_MAP1_INDEX:
     1538               *v = ctx->EvalMap.Map1Index.Order;
     1539               break;
     1540            case GL_MAP1_NORMAL:
     1541               *v = ctx->EvalMap.Map1Normal.Order;
     1542               break;
     1543            case GL_MAP1_TEXTURE_COORD_1:
     1544               *v = ctx->EvalMap.Map1Texture1.Order;
     1545               break;
     1546            case GL_MAP1_TEXTURE_COORD_2:
     1547               *v = ctx->EvalMap.Map1Texture2.Order;
     1548               break;
     1549            case GL_MAP1_TEXTURE_COORD_3:
     1550               *v = ctx->EvalMap.Map1Texture3.Order;
     1551               break;
     1552            case GL_MAP1_TEXTURE_COORD_4:
     1553               *v = ctx->EvalMap.Map1Texture4.Order;
     1554               break;
     1555            case GL_MAP1_VERTEX_3:
     1556               *v = ctx->EvalMap.Map1Vertex3.Order;
     1557               break;
     1558            case GL_MAP1_VERTEX_4:
     1559               *v = ctx->EvalMap.Map1Vertex4.Order;
     1560               break;
     1561            case GL_MAP2_COLOR_4:
     1562               v[0] = ctx->EvalMap.Map2Color4.Uorder;
     1563               v[1] = ctx->EvalMap.Map2Color4.Vorder;
     1564               break;
     1565            case GL_MAP2_INDEX:
     1566               v[0] = ctx->EvalMap.Map2Index.Uorder;
     1567               v[1] = ctx->EvalMap.Map2Index.Vorder;
     1568               break;
     1569            case GL_MAP2_NORMAL:
     1570               v[0] = ctx->EvalMap.Map2Normal.Uorder;
     1571               v[1] = ctx->EvalMap.Map2Normal.Vorder;
     1572               break;
     1573            case GL_MAP2_TEXTURE_COORD_1:
     1574               v[0] = ctx->EvalMap.Map2Texture1.Uorder;
     1575               v[1] = ctx->EvalMap.Map2Texture1.Vorder;
     1576               break;
     1577            case GL_MAP2_TEXTURE_COORD_2:
     1578               v[0] = ctx->EvalMap.Map2Texture2.Uorder;
     1579               v[1] = ctx->EvalMap.Map2Texture2.Vorder;
     1580               break;
     1581            case GL_MAP2_TEXTURE_COORD_3:
     1582               v[0] = ctx->EvalMap.Map2Texture3.Uorder;
     1583               v[1] = ctx->EvalMap.Map2Texture3.Vorder;
     1584               break;
     1585            case GL_MAP2_TEXTURE_COORD_4:
     1586               v[0] = ctx->EvalMap.Map2Texture4.Uorder;
     1587               v[1] = ctx->EvalMap.Map2Texture4.Vorder;
     1588               break;
     1589            case GL_MAP2_VERTEX_3:
     1590               v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
     1591               v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
     1592               break;
     1593            case GL_MAP2_VERTEX_4:
     1594               v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
     1595               v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
     1596               break;
     1597            default:
     1598               gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
     1599               return;
     1600        }
    16151601         break;
    16161602      case GL_DOMAIN:
    1617         switch (target) {
    1618             case GL_MAP1_COLOR_4:
    1619                v[0] = ctx->EvalMap.Map1Color4.u1;
    1620                v[1] = ctx->EvalMap.Map1Color4.u2;
    1621                break;
    1622             case GL_MAP1_INDEX:
    1623                v[0] = ctx->EvalMap.Map1Index.u1;
    1624                v[1] = ctx->EvalMap.Map1Index.u2;
    1625                break;
    1626             case GL_MAP1_NORMAL:
    1627                v[0] = ctx->EvalMap.Map1Normal.u1;
    1628                v[1] = ctx->EvalMap.Map1Normal.u2;
    1629                break;
    1630             case GL_MAP1_TEXTURE_COORD_1:
    1631                v[0] = ctx->EvalMap.Map1Texture1.u1;
    1632                v[1] = ctx->EvalMap.Map1Texture1.u2;
    1633                break;
    1634             case GL_MAP1_TEXTURE_COORD_2:
    1635                v[0] = ctx->EvalMap.Map1Texture2.u1;
    1636                v[1] = ctx->EvalMap.Map1Texture2.u2;
    1637                break;
    1638             case GL_MAP1_TEXTURE_COORD_3:
    1639                v[0] = ctx->EvalMap.Map1Texture3.u1;
    1640                v[1] = ctx->EvalMap.Map1Texture3.u2;
    1641                break;
    1642             case GL_MAP1_TEXTURE_COORD_4:
    1643                v[0] = ctx->EvalMap.Map1Texture4.u1;
    1644                v[1] = ctx->EvalMap.Map1Texture4.u2;
    1645                break;
    1646             case GL_MAP1_VERTEX_3:
    1647                v[0] = ctx->EvalMap.Map1Vertex3.u1;
    1648                v[1] = ctx->EvalMap.Map1Vertex3.u2;
    1649                break;
    1650             case GL_MAP1_VERTEX_4:
    1651                v[0] = ctx->EvalMap.Map1Vertex4.u1;
    1652                v[1] = ctx->EvalMap.Map1Vertex4.u2;
    1653                break;
    1654             case GL_MAP2_COLOR_4:
    1655                v[0] = ctx->EvalMap.Map2Color4.u1;
    1656                v[1] = ctx->EvalMap.Map2Color4.u2;
    1657                v[2] = ctx->EvalMap.Map2Color4.v1;
    1658                v[3] = ctx->EvalMap.Map2Color4.v2;
    1659                break;
    1660             case GL_MAP2_INDEX:
    1661                v[0] = ctx->EvalMap.Map2Index.u1;
    1662                v[1] = ctx->EvalMap.Map2Index.u2;
    1663                v[2] = ctx->EvalMap.Map2Index.v1;
    1664                v[3] = ctx->EvalMap.Map2Index.v2;
    1665                break;
    1666             case GL_MAP2_NORMAL:
    1667                v[0] = ctx->EvalMap.Map2Normal.u1;
    1668                v[1] = ctx->EvalMap.Map2Normal.u2;
    1669                v[2] = ctx->EvalMap.Map2Normal.v1;
    1670                v[3] = ctx->EvalMap.Map2Normal.v2;
    1671                break;
    1672             case GL_MAP2_TEXTURE_COORD_1:
    1673                v[0] = ctx->EvalMap.Map2Texture1.u1;
    1674                v[1] = ctx->EvalMap.Map2Texture1.u2;
    1675                v[2] = ctx->EvalMap.Map2Texture1.v1;
    1676                v[3] = ctx->EvalMap.Map2Texture1.v2;
    1677                break;
    1678             case GL_MAP2_TEXTURE_COORD_2:
    1679                v[0] = ctx->EvalMap.Map2Texture2.u1;
    1680                v[1] = ctx->EvalMap.Map2Texture2.u2;
    1681                v[2] = ctx->EvalMap.Map2Texture2.v1;
    1682                v[3] = ctx->EvalMap.Map2Texture2.v2;
    1683                break;
    1684             case GL_MAP2_TEXTURE_COORD_3:
    1685                v[0] = ctx->EvalMap.Map2Texture3.u1;
    1686                v[1] = ctx->EvalMap.Map2Texture3.u2;
    1687                v[2] = ctx->EvalMap.Map2Texture3.v1;
    1688                v[3] = ctx->EvalMap.Map2Texture3.v2;
    1689                break;
    1690             case GL_MAP2_TEXTURE_COORD_4:
    1691                v[0] = ctx->EvalMap.Map2Texture4.u1;
    1692                v[1] = ctx->EvalMap.Map2Texture4.u2;
    1693                v[2] = ctx->EvalMap.Map2Texture4.v1;
    1694                v[3] = ctx->EvalMap.Map2Texture4.v2;
    1695                break;
    1696             case GL_MAP2_VERTEX_3:
    1697                v[0] = ctx->EvalMap.Map2Vertex3.u1;
    1698                v[1] = ctx->EvalMap.Map2Vertex3.u2;
    1699                v[2] = ctx->EvalMap.Map2Vertex3.v1;
    1700                v[3] = ctx->EvalMap.Map2Vertex3.v2;
    1701                break;
    1702             case GL_MAP2_VERTEX_4:
    1703                v[0] = ctx->EvalMap.Map2Vertex4.u1;
    1704                v[1] = ctx->EvalMap.Map2Vertex4.u2;
    1705                v[2] = ctx->EvalMap.Map2Vertex4.v1;
    1706                v[3] = ctx->EvalMap.Map2Vertex4.v2;
    1707                break;
    1708             default:
    1709                gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
    1710         }
     1603        switch (target) {
     1604            case GL_MAP1_COLOR_4:
     1605               v[0] = ctx->EvalMap.Map1Color4.u1;
     1606               v[1] = ctx->EvalMap.Map1Color4.u2;
     1607               break;
     1608            case GL_MAP1_INDEX:
     1609               v[0] = ctx->EvalMap.Map1Index.u1;
     1610               v[1] = ctx->EvalMap.Map1Index.u2;
     1611               break;
     1612            case GL_MAP1_NORMAL:
     1613               v[0] = ctx->EvalMap.Map1Normal.u1;
     1614               v[1] = ctx->EvalMap.Map1Normal.u2;
     1615               break;
     1616            case GL_MAP1_TEXTURE_COORD_1:
     1617               v[0] = ctx->EvalMap.Map1Texture1.u1;
     1618               v[1] = ctx->EvalMap.Map1Texture1.u2;
     1619               break;
     1620            case GL_MAP1_TEXTURE_COORD_2:
     1621               v[0] = ctx->EvalMap.Map1Texture2.u1;
     1622               v[1] = ctx->EvalMap.Map1Texture2.u2;
     1623               break;
     1624            case GL_MAP1_TEXTURE_COORD_3:
     1625               v[0] = ctx->EvalMap.Map1Texture3.u1;
     1626               v[1] = ctx->EvalMap.Map1Texture3.u2;
     1627               break;
     1628            case GL_MAP1_TEXTURE_COORD_4:
     1629               v[0] = ctx->EvalMap.Map1Texture4.u1;
     1630               v[1] = ctx->EvalMap.Map1Texture4.u2;
     1631               break;
     1632            case GL_MAP1_VERTEX_3:
     1633               v[0] = ctx->EvalMap.Map1Vertex3.u1;
     1634               v[1] = ctx->EvalMap.Map1Vertex3.u2;
     1635               break;
     1636            case GL_MAP1_VERTEX_4:
     1637               v[0] = ctx->EvalMap.Map1Vertex4.u1;
     1638               v[1] = ctx->EvalMap.Map1Vertex4.u2;
     1639               break;
     1640            case GL_MAP2_COLOR_4:
     1641               v[0] = ctx->EvalMap.Map2Color4.u1;
     1642               v[1] = ctx->EvalMap.Map2Color4.u2;
     1643               v[2] = ctx->EvalMap.Map2Color4.v1;
     1644               v[3] = ctx->EvalMap.Map2Color4.v2;
     1645               break;
     1646            case GL_MAP2_INDEX:
     1647               v[0] = ctx->EvalMap.Map2Index.u1;
     1648               v[1] = ctx->EvalMap.Map2Index.u2;
     1649               v[2] = ctx->EvalMap.Map2Index.v1;
     1650               v[3] = ctx->EvalMap.Map2Index.v2;
     1651               break;
     1652            case GL_MAP2_NORMAL:
     1653               v[0] = ctx->EvalMap.Map2Normal.u1;
     1654               v[1] = ctx->EvalMap.Map2Normal.u2;
     1655               v[2] = ctx->EvalMap.Map2Normal.v1;
     1656               v[3] = ctx->EvalMap.Map2Normal.v2;
     1657               break;
     1658            case GL_MAP2_TEXTURE_COORD_1:
     1659               v[0] = ctx->EvalMap.Map2Texture1.u1;
     1660               v[1] = ctx->EvalMap.Map2Texture1.u2;
     1661               v[2] = ctx->EvalMap.Map2Texture1.v1;
     1662               v[3] = ctx->EvalMap.Map2Texture1.v2;
     1663               break;
     1664            case GL_MAP2_TEXTURE_COORD_2:
     1665               v[0] = ctx->EvalMap.Map2Texture2.u1;
     1666               v[1] = ctx->EvalMap.Map2Texture2.u2;
     1667               v[2] = ctx->EvalMap.Map2Texture2.v1;
     1668               v[3] = ctx->EvalMap.Map2Texture2.v2;
     1669               break;
     1670            case GL_MAP2_TEXTURE_COORD_3:
     1671               v[0] = ctx->EvalMap.Map2Texture3.u1;
     1672               v[1] = ctx->EvalMap.Map2Texture3.u2;
     1673               v[2] = ctx->EvalMap.Map2Texture3.v1;
     1674               v[3] = ctx->EvalMap.Map2Texture3.v2;
     1675               break;
     1676            case GL_MAP2_TEXTURE_COORD_4:
     1677               v[0] = ctx->EvalMap.Map2Texture4.u1;
     1678               v[1] = ctx->EvalMap.Map2Texture4.u2;
     1679               v[2] = ctx->EvalMap.Map2Texture4.v1;
     1680               v[3] = ctx->EvalMap.Map2Texture4.v2;
     1681               break;
     1682            case GL_MAP2_VERTEX_3:
     1683               v[0] = ctx->EvalMap.Map2Vertex3.u1;
     1684               v[1] = ctx->EvalMap.Map2Vertex3.u2;
     1685               v[2] = ctx->EvalMap.Map2Vertex3.v1;
     1686               v[3] = ctx->EvalMap.Map2Vertex3.v2;
     1687               break;
     1688            case GL_MAP2_VERTEX_4:
     1689               v[0] = ctx->EvalMap.Map2Vertex4.u1;
     1690               v[1] = ctx->EvalMap.Map2Vertex4.u2;
     1691               v[2] = ctx->EvalMap.Map2Vertex4.v1;
     1692               v[3] = ctx->EvalMap.Map2Vertex4.v2;
     1693               break;
     1694            default:
     1695               gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
     1696        }
    17111697         break;
    17121698      default:
    … …  
    17161702
    17171703
    1718 void gl_GetMapiv( GLcontext* ctx, GLenum target, GLenum query, GLint *v )
    1719 {
     1704void
     1705_mesa_GetMapiv( GLenum target, GLenum query, GLint *v )
     1706{
     1707   GET_CURRENT_CONTEXT(ctx);
    17201708   GLuint i, n;
    17211709   GLfloat *data;
    … …  
    17231711   switch (query) {
    17241712      case GL_COEFF:
    1725         switch (target) {
    1726             case GL_MAP1_COLOR_4:
    1727                data = ctx->EvalMap.Map1Color4.Points;
    1728                n = ctx->EvalMap.Map1Color4.Order * 4;
    1729                break;
    1730             case GL_MAP1_INDEX:
    1731                data = ctx->EvalMap.Map1Index.Points;
    1732                n = ctx->EvalMap.Map1Index.Order;
    1733                break;
    1734             case GL_MAP1_NORMAL:
    1735                data = ctx->EvalMap.Map1Normal.Points;
    1736                n = ctx->EvalMap.Map1Normal.Order * 3;
    1737                break;
    1738             case GL_MAP1_TEXTURE_COORD_1:
    1739                data = ctx->EvalMap.Map1Texture1.Points;
    1740                n = ctx->EvalMap.Map1Texture1.Order * 1;
    1741                break;
    1742             case GL_MAP1_TEXTURE_COORD_2:
    1743                data = ctx->EvalMap.Map1Texture2.Points;
    1744                n = ctx->EvalMap.Map1Texture2.Order * 2;
    1745                break;
    1746             case GL_MAP1_TEXTURE_COORD_3:
    1747                data = ctx->EvalMap.Map1Texture3.Points;
    1748                n = ctx->EvalMap.Map1Texture3.Order * 3;
    1749                break;
    1750             case GL_MAP1_TEXTURE_COORD_4:
    1751                data = ctx->EvalMap.Map1Texture4.Points;
    1752                n = ctx->EvalMap.Map1Texture4.Order * 4;
    1753                break;
    1754             case GL_MAP1_VERTEX_3:
    1755                data = ctx->EvalMap.Map1Vertex3.Points;
    1756                n = ctx->EvalMap.Map1Vertex3.Order * 3;
    1757                break;
    1758             case GL_MAP1_VERTEX_4:
    1759                data = ctx->EvalMap.Map1Vertex4.Points;
    1760                n = ctx->EvalMap.Map1Vertex4.Order * 4;
    1761                break;
    1762             case GL_MAP2_COLOR_4:
    1763                data = ctx->EvalMap.Map2Color4.Points;
    1764                n = ctx->EvalMap.Map2Color4.Uorder
     1713        switch (target) {
     1714            case GL_MAP1_COLOR_4:
     1715               data = ctx->EvalMap.Map1Color4.Points;
     1716               n = ctx->EvalMap.Map1Color4.Order * 4;
     1717               break;
     1718            case GL_MAP1_INDEX:
     1719               data = ctx->EvalMap.Map1Index.Points;
     1720               n = ctx->EvalMap.Map1Index.Order;
     1721               break;
     1722            case GL_MAP1_NORMAL:
     1723               data = ctx->EvalMap.Map1Normal.Points;
     1724               n = ctx->EvalMap.Map1Normal.Order * 3;
     1725               break;
     1726            case GL_MAP1_TEXTURE_COORD_1:
     1727               data = ctx->EvalMap.Map1Texture1.Points;
     1728               n = ctx->EvalMap.Map1Texture1.Order * 1;
     1729               break;
     1730            case GL_MAP1_TEXTURE_COORD_2:
     1731               data = ctx->EvalMap.Map1Texture2.Points;
     1732               n = ctx->EvalMap.Map1Texture2.Order * 2;
     1733               break;
     1734            case GL_MAP1_TEXTURE_COORD_3:
     1735               data = ctx->EvalMap.Map1Texture3.Points;
     1736               n = ctx->EvalMap.Map1Texture3.Order * 3;
     1737               break;
     1738            case GL_MAP1_TEXTURE_COORD_4:
     1739               data = ctx->EvalMap.Map1Texture4.Points;
     1740               n = ctx->EvalMap.Map1Texture4.Order * 4;
     1741               break;
     1742            case GL_MAP1_VERTEX_3:
     1743               data = ctx->EvalMap.Map1Vertex3.Points;
     1744               n = ctx->EvalMap.Map1Vertex3.Order * 3;
     1745               break;
     1746            case GL_MAP1_VERTEX_4:
     1747               data = ctx->EvalMap.Map1Vertex4.Points;
     1748               n = ctx->EvalMap.Map1Vertex4.Order * 4;
     1749               break;
     1750            case GL_MAP2_COLOR_4:
     1751               data = ctx->EvalMap.Map2Color4.Points;
     1752               n = ctx->EvalMap.Map2Color4.Uorder
    17651753                 * ctx->EvalMap.Map2Color4.Vorder * 4;
    1766                break;
    1767             case GL_MAP2_INDEX:
    1768                data = ctx->EvalMap.Map2Index.Points;
    1769                n = ctx->EvalMap.Map2Index.Uorder
     1754               break;
     1755            case GL_MAP2_INDEX:
     1756               data = ctx->EvalMap.Map2Index.Points;
     1757               n = ctx->EvalMap.Map2Index.Uorder
    17701758                 * ctx->EvalMap.Map2Index.Vorder;
    1771                break;
    1772             case GL_MAP2_NORMAL:
    1773                data = ctx->EvalMap.Map2Normal.Points;
    1774                n = ctx->EvalMap.Map2Normal.Uorder
     1759               break;
     1760            case GL_MAP2_NORMAL:
     1761               data = ctx->EvalMap.Map2Normal.Points;
     1762               n = ctx->EvalMap.Map2Normal.Uorder
    17751763                 * ctx->EvalMap.Map2Normal.Vorder * 3;
    1776                break;
    1777             case GL_MAP2_TEXTURE_COORD_1:
    1778                data = ctx->EvalMap.Map2Texture1.Points;
    1779                n = ctx->EvalMap.Map2Texture1.Uorder
     1764               break;
     1765            case GL_MAP2_TEXTURE_COORD_1:
     1766               data = ctx->EvalMap.Map2Texture1.Points;
     1767               n = ctx->EvalMap.Map2Texture1.Uorder
    17801768                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
    1781                break;
    1782             case GL_MAP2_TEXTURE_COORD_2:
    1783                data = ctx->EvalMap.Map2Texture2.Points;
    1784                n = ctx->EvalMap.Map2Texture2.Uorder
     1769               break;
     1770            case GL_MAP2_TEXTURE_COORD_2:
     1771               data = ctx->EvalMap.Map2Texture2.Points;
     1772               n = ctx->EvalMap.Map2Texture2.Uorder
    17851773                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
    1786                break;
    1787             case GL_MAP2_TEXTURE_COORD_3:
    1788                data = ctx->EvalMap.Map2Texture3.Points;
    1789                n = ctx->EvalMap.Map2Texture3.Uorder
     1774               break;
     1775            case GL_MAP2_TEXTURE_COORD_3:
     1776               data = ctx->EvalMap.Map2Texture3.Points;
     1777               n = ctx->EvalMap.Map2Texture3.Uorder
    17901778                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
    1791                break;
    1792             case GL_MAP2_TEXTURE_COORD_4:
    1793                data = ctx->EvalMap.Map2Texture4.Points;
    1794                n = ctx->EvalMap.Map2Texture4.Uorder
     1779               break;
     1780            case GL_MAP2_TEXTURE_COORD_4:
     1781               data = ctx->EvalMap.Map2Texture4.Points;
     1782               n = ctx->EvalMap.Map2Texture4.Uorder
    17951783                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
    1796                break;
    1797             case GL_MAP2_VERTEX_3:
    1798                data = ctx->EvalMap.Map2Vertex3.Points;
    1799                n = ctx->EvalMap.Map2Vertex3.Uorder
     1784               break;
     1785            case GL_MAP2_VERTEX_3:
     1786               data = ctx->EvalMap.Map2Vertex3.Points;
     1787               n = ctx->EvalMap.Map2Vertex3.Uorder
    18001788                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
    1801                break;
    1802             case GL_MAP2_VERTEX_4:
    1803                data = ctx->EvalMap.Map2Vertex4.Points;
    1804                n = ctx->EvalMap.Map2Vertex4.Uorder
     1789               break;
     1790            case GL_MAP2_VERTEX_4:
     1791               data = ctx->EvalMap.Map2Vertex4.Points;
     1792               n = ctx->EvalMap.Map2Vertex4.Uorder
    18051793                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
    1806                break;
    1807             default:
    1808                gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
    1809                return;
    1810         }
    1811         if (data) {
    1812             for (i=0;i<n;i++) {
    1813                v[i] = ROUNDF(data[i]);
    1814             }
    1815         }
     1794               break;
     1795            default:
     1796               gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
     1797               return;
     1798        }
     1799        if (data) {
     1800            for (i=0;i<n;i++) {
     1801               v[i] = ROUNDF(data[i]);
     1802            }
     1803        }
    18161804         break;
    18171805      case GL_ORDER:
    1818         switch (target) {
    1819             case GL_MAP1_COLOR_4:
    1820                *v = ctx->EvalMap.Map1Color4.Order;
    1821                break;
    1822             case GL_MAP1_INDEX:
    1823                *v = ctx->EvalMap.Map1Index.Order;
    1824                break;
    1825             case GL_MAP1_NORMAL:
    1826                *v = ctx->EvalMap.Map1Normal.Order;
    1827                break;
    1828             case GL_MAP1_TEXTURE_COORD_1:
    1829                *v = ctx->EvalMap.Map1Texture1.Order;
    1830                break;
    1831             case GL_MAP1_TEXTURE_COORD_2:
    1832                *v = ctx->EvalMap.Map1Texture2.Order;
    1833                break;
    1834             case GL_MAP1_TEXTURE_COORD_3:
    1835                *v = ctx->EvalMap.Map1Texture3.Order;
    1836                break;
    1837             case GL_MAP1_TEXTURE_COORD_4:
    1838                *v = ctx->EvalMap.Map1Texture4.Order;
    1839                break;
    1840             case GL_MAP1_VERTEX_3:
    1841                *v = ctx->EvalMap.Map1Vertex3.Order;
    1842                break;
    1843             case GL_MAP1_VERTEX_4:
    1844                *v = ctx->EvalMap.Map1Vertex4.Order;
    1845                break;
    1846             case GL_MAP2_COLOR_4:
    1847                v[0] = ctx->EvalMap.Map2Color4.Uorder;
    1848                v[1] = ctx->EvalMap.Map2Color4.Vorder;
    1849                break;
    1850             case GL_MAP2_INDEX:
    1851                v[0] = ctx->EvalMap.Map2Index.Uorder;
    1852                v[1] = ctx->EvalMap.Map2Index.Vorder;
    1853                break;
    1854             case GL_MAP2_NORMAL:
    1855                v[0] = ctx->EvalMap.Map2Normal.Uorder;
    1856                v[1] = ctx->EvalMap.Map2Normal.Vorder;
    1857                break;
    1858             case GL_MAP2_TEXTURE_COORD_1:
    1859                v[0] = ctx->EvalMap.Map2Texture1.Uorder;
    1860                v[1] = ctx->EvalMap.Map2Texture1.Vorder;
    1861                break;
    1862             case GL_MAP2_TEXTURE_COORD_2:
    1863                v[0] = ctx->EvalMap.Map2Texture2.Uorder;
    1864                v[1] = ctx->EvalMap.Map2Texture2.Vorder;
    1865                break;
    1866             case GL_MAP2_TEXTURE_COORD_3:
    1867                v[0] = ctx->EvalMap.Map2Texture3.Uorder;
    1868                v[1] = ctx->EvalMap.Map2Texture3.Vorder;
    1869                break;
    1870             case GL_MAP2_TEXTURE_COORD_4:
    1871                v[0] = ctx->EvalMap.Map2Texture4.Uorder;
    1872                v[1] = ctx->EvalMap.Map2Texture4.Vorder;
    1873                break;
    1874             case GL_MAP2_VERTEX_3:
    1875                v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
    1876                v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
    1877                break;
    1878             case GL_MAP2_VERTEX_4:
    1879                v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
    1880                v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
    1881                break;
    1882             default:
    1883                gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
    1884                return;
    1885         }
     1806        switch (target) {
     1807            case GL_MAP1_COLOR_4:
     1808               *v = ctx->EvalMap.Map1Color4.Order;
     1809               break;
     1810            case GL_MAP1_INDEX:
     1811               *v = ctx->EvalMap.Map1Index.Order;
     1812               break;
     1813            case GL_MAP1_NORMAL:
     1814               *v = ctx->EvalMap.Map1Normal.Order;
     1815               break;
     1816            case GL_MAP1_TEXTURE_COORD_1:
     1817               *v = ctx->EvalMap.Map1Texture1.Order;
     1818               break;
     1819            case GL_MAP1_TEXTURE_COORD_2:
     1820               *v = ctx->EvalMap.Map1Texture2.Order;
     1821               break;
     1822            case GL_MAP1_TEXTURE_COORD_3:
     1823               *v = ctx->EvalMap.Map1Texture3.Order;
     1824               break;
     1825            case GL_MAP1_TEXTURE_COORD_4:
     1826               *v = ctx->EvalMap.Map1Texture4.Order;
     1827               break;
     1828            case GL_MAP1_VERTEX_3:
     1829               *v = ctx->EvalMap.Map1Vertex3.Order;
     1830               break;
     1831            case GL_MAP1_VERTEX_4:
     1832               *v = ctx->EvalMap.Map1Vertex4.Order;
     1833               break;
     1834            case GL_MAP2_COLOR_4:
     1835               v[0] = ctx->EvalMap.Map2Color4.Uorder;
     1836               v[1] = ctx->EvalMap.Map2Color4.Vorder;
     1837               break;
     1838            case GL_MAP2_INDEX:
     1839               v[0] = ctx->EvalMap.Map2Index.Uorder;
     1840               v[1] = ctx->EvalMap.Map2Index.Vorder;
     1841               break;
     1842            case GL_MAP2_NORMAL:
     1843               v[0] = ctx->EvalMap.Map2Normal.Uorder;
     1844               v[1] = ctx->EvalMap.Map2Normal.Vorder;
     1845               break;
     1846            case GL_MAP2_TEXTURE_COORD_1:
     1847               v[0] = ctx->EvalMap.Map2Texture1.Uorder;
     1848               v[1] = ctx->EvalMap.Map2Texture1.Vorder;
     1849               break;
     1850            case GL_MAP2_TEXTURE_COORD_2:
     1851               v[0] = ctx->EvalMap.Map2Texture2.Uorder;
     1852               v[1] = ctx->EvalMap.Map2Texture2.Vorder;
     1853               break;
     1854            case GL_MAP2_TEXTURE_COORD_3:
     1855               v[0] = ctx->EvalMap.Map2Texture3.Uorder;
     1856               v[1] = ctx->EvalMap.Map2Texture3.Vorder;
     1857               break;
     1858            case GL_MAP2_TEXTURE_COORD_4:
     1859               v[0] = ctx->EvalMap.Map2Texture4.Uorder;
     1860               v[1] = ctx->EvalMap.Map2Texture4.Vorder;
     1861               break;
     1862            case GL_MAP2_VERTEX_3:
     1863               v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
     1864               v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
     1865               break;
     1866            case GL_MAP2_VERTEX_4:
     1867               v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
     1868               v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
     1869               break;
     1870            default:
     1871               gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
     1872               return;
     1873        }
    18861874         break;
    18871875      case GL_DOMAIN:
    1888         switch (target) {
    1889             case GL_MAP1_COLOR_4:
    1890                v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
    1891                v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
    1892                break;
    1893             case GL_MAP1_INDEX:
    1894                v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
    1895                v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
    1896                break;
    1897             case GL_MAP1_NORMAL:
    1898                v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
    1899                v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
    1900                break;
    1901             case GL_MAP1_TEXTURE_COORD_1:
    1902                v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
    1903                v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
    1904                break;
    1905             case GL_MAP1_TEXTURE_COORD_2:
    1906                v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
    1907                v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
    1908                break;
    1909             case GL_MAP1_TEXTURE_COORD_3:
    1910                v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
    1911                v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
    1912                break;
    1913             case GL_MAP1_TEXTURE_COORD_4:
    1914                v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
    1915                v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
    1916                break;
    1917             case GL_MAP1_VERTEX_3:
    1918                v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
    1919                v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
    1920                break;
    1921             case GL_MAP1_VERTEX_4:
    1922                v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
    1923                v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
    1924                break;
    1925             case GL_MAP2_COLOR_4:
    1926                v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
    1927                v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
    1928                v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
    1929                v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
    1930                break;
    1931             case GL_MAP2_INDEX:
    1932                v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
    1933                v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
    1934                v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
    1935                v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
    1936                break;
    1937             case GL_MAP2_NORMAL:
    1938                v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
    1939                v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
    1940                v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
    1941                v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
    1942                break;
    1943             case GL_MAP2_TEXTURE_COORD_1:
    1944                v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
    1945                v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
    1946                v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
    1947                v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
    1948                break;
    1949             case GL_MAP2_TEXTURE_COORD_2:
    1950                v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
    1951                v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
    1952                v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
    1953                v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
    1954                break;
    1955             case GL_MAP2_TEXTURE_COORD_3:
    1956                v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
    1957                v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
    1958                v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
    1959                v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
    1960                break;
    1961             case GL_MAP2_TEXTURE_COORD_4:
    1962                v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
    1963                v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
    1964                v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
    1965                v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
    1966                break;
    1967             case GL_MAP2_VERTEX_3:
    1968                v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
    1969                v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
    1970                v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
    1971                v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
    1972                break;
    1973             case GL_MAP2_VERTEX_4:
    1974                v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
    1975                v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
    1976                v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
    1977                v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
    1978                break;
    1979             default:
    1980                gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
    1981         }
     1876        switch (target) {
     1877            case GL_MAP1_COLOR_4:
     1878               v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
     1879               v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
     1880               break;
     1881            case GL_MAP1_INDEX:
     1882               v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
     1883               v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
     1884               break;
     1885            case GL_MAP1_NORMAL:
     1886               v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
     1887               v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
     1888               break;
     1889            case GL_MAP1_TEXTURE_COORD_1:
     1890               v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
     1891               v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
     1892               break;
     1893            case GL_MAP1_TEXTURE_COORD_2:
     1894               v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
     1895               v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
     1896               break;
     1897            case GL_MAP1_TEXTURE_COORD_3:
     1898               v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
     1899               v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
     1900               break;
     1901            case GL_MAP1_TEXTURE_COORD_4:
     1902               v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
     1903               v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
     1904               break;
     1905            case GL_MAP1_VERTEX_3:
     1906               v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
     1907               v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
     1908               break;
     1909            case GL_MAP1_VERTEX_4:
     1910               v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
     1911               v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
     1912               break;
     1913            case GL_MAP2_COLOR_4:
     1914               v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
     1915               v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
     1916               v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
     1917               v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
     1918               break;
     1919            case GL_MAP2_INDEX:
     1920               v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
     1921               v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
     1922               v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
     1923               v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
     1924               break;
     1925            case GL_MAP2_NORMAL:
     1926               v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
     1927               v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
     1928               v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
     1929               v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
     1930               break;
     1931            case GL_MAP2_TEXTURE_COORD_1:
     1932               v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
     1933               v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
     1934               v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
     1935               v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
     1936               break;
     1937            case GL_MAP2_TEXTURE_COORD_2:
     1938               v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
     1939               v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
     1940               v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
     1941               v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
     1942               break;
     1943            case GL_MAP2_TEXTURE_COORD_3:
     1944               v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
     1945               v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
     1946               v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
     1947               v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
     1948               break;
     1949            case GL_MAP2_TEXTURE_COORD_4:
     1950               v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
     1951               v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
     1952               v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
     1953               v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
     1954               break;
     1955            case GL_MAP2_VERTEX_3:
     1956               v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
     1957               v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
     1958               v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
     1959               v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
     1960               break;
     1961            case GL_MAP2_VERTEX_4:
     1962               v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
     1963               v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
     1964               v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
     1965               v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
     1966               break;
     1967            default:
     1968               gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
     1969        }
    19821970         break;
    19831971      default:
    … …  
    19891977
    19901978static void eval_points1( GLfloat outcoord[][4],
    1991                           GLfloat coord[][4],
    1992                           const GLuint *flags,
    1993                           GLuint start,
    1994                           GLfloat du, GLfloat u1 )
     1979                          GLfloat coord[][4],
     1980                          const GLuint *flags,
     1981                          GLuint start,
     1982                          GLfloat du, GLfloat u1 )
    19951983{
    19961984   GLuint i;
    19971985   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    19981986      if (flags[i] & VERT_EVAL_P1)
    1999         outcoord[i][0] = coord[i][0] * du + u1;
     1987        outcoord[i][0] = coord[i][0] * du + u1;
    20001988      else if (flags[i] & VERT_EVAL_ANY) {
    2001         outcoord[i][0] = coord[i][0];
    2002         outcoord[i][1] = coord[i][1];
     1989        outcoord[i][0] = coord[i][0];
     1990        outcoord[i][1] = coord[i][1];
    20031991      }
    20041992}
    20051993
    20061994static void eval_points2( GLfloat outcoord[][4],
    2007                           GLfloat coord[][4],
    2008                           const GLuint *flags,
    2009                           GLuint start,
    2010                           GLfloat du, GLfloat u1,
    2011                           GLfloat dv, GLfloat v1 )
     1995                          GLfloat coord[][4],
     1996                          const GLuint *flags,
     1997                          GLuint start,
     1998                          GLfloat du, GLfloat u1,
     1999                          GLfloat dv, GLfloat v1 )
    20122000{
    20132001   GLuint i;
    20142002   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    20152003      if (flags[i] & VERT_EVAL_P2) {
    2016         outcoord[i][0] = coord[i][0] * du + u1;
    2017         outcoord[i][1] = coord[i][1] * dv + v1;
     2004        outcoord[i][0] = coord[i][0] * du + u1;
     2005        outcoord[i][1] = coord[i][1] * dv + v1;
    20182006      } else if (flags[i] & VERT_EVAL_ANY) {
    2019         outcoord[i][0] = coord[i][0];
    2020         outcoord[i][1] = coord[i][1];
     2007        outcoord[i][0] = coord[i][0];
     2008        outcoord[i][1] = coord[i][1];
    20212009      }
    20222010}
    … …  
    20242012
    20252013static const GLubyte dirty_flags[5] = {
    2026    0,                           /* not possible */
     2014   0,                           /* not possible */
    20272015   VEC_DIRTY_0,
    20282016   VEC_DIRTY_1,
    … …  
    20332021
    20342022static GLvector4f *eval1_4f( GLvector4f *dest,
    2035                              GLfloat coord[][4],
    2036                              const GLuint *flags,
    2037                              GLuint start,
    2038                              GLuint dimension,
    2039                              struct gl_1d_map *map )
     2023                             GLfloat coord[][4],
     2024                             const GLuint *flags,
     2025                             GLuint start,
     2026                             GLuint dimension,
     2027                             struct gl_1d_map *map )
    20402028{
    20412029   const GLfloat u1 = map->u1;
    … …  
    20462034   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    20472035      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
    2048         GLfloat u = (coord[i][0] - u1) * du;
    2049         ASSIGN_4V(to[i], 0,0,0,1);
    2050         horner_bezier_curve(map->Points, to[i], u, dimension, map->Order);
     2036        GLfloat u = (coord[i][0] - u1) * du;
     2037        ASSIGN_4V(to[i], 0,0,0,1);
     2038        horner_bezier_curve(map->Points, to[i], u, dimension, map->Order);
    20512039      }
    20522040
    … …  
    20602048
    20612049static GLvector1ui *eval1_1ui( GLvector1ui *dest,
    2062                                GLfloat coord[][4],
    2063                                const GLuint *flags,
    2064                                GLuint start,
    2065                                struct gl_1d_map *map )
     2050                               GLfloat coord[][4],
     2051                               const GLuint *flags,
     2052                               GLuint start,
     2053                               struct gl_1d_map *map )
    20662054{
    20672055   const GLfloat u1 = map->u1;
    … …  
    20722060   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    20732061      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
    2074         GLfloat u = (coord[i][0] - u1) * du;
    2075         GLfloat tmp;
    2076         horner_bezier_curve(map->Points, &tmp, u, 1, map->Order);
    2077         to[i] = (GLuint) (GLint) tmp;
     2062        GLfloat u = (coord[i][0] - u1) * du;
     2063        GLfloat tmp;
     2064        horner_bezier_curve(map->Points, &tmp, u, 1, map->Order);
     2065        to[i] = (GLuint) (GLint) tmp;
    20782066      }
    20792067
    … …  
    20842072
    20852073static GLvector3f *eval1_norm( GLvector3f *dest,
    2086                                GLfloat coord[][4],
    2087                                GLuint *flags, /* not const */
    2088                                GLuint start,
    2089                                struct gl_1d_map *map )
     2074                               GLfloat coord[][4],
     2075                               GLuint *flags, /* not const */
     2076                               GLuint start,
     2077                               struct gl_1d_map *map )
    20902078{
    20912079   const GLfloat u1 = map->u1;
    … …  
    20962084   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    20972085      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
    2098         GLfloat u = (coord[i][0] - u1) * du;
    2099         horner_bezier_curve(map->Points, to[i], u, 3, map->Order);
    2100         flags[i+1] |= VERT_NORM; /* reset */
     2086        GLfloat u = (coord[i][0] - u1) * du;
     2087        horner_bezier_curve(map->Points, to[i], u, 3, map->Order);
     2088        flags[i+1] |= VERT_NORM; /* reset */
    21012089      }
    21022090
    … …  
    21072095
    21082096static GLvector4ub *eval1_color( GLvector4ub *dest,
    2109                                 GLfloat coord[][4],
    2110                                 GLuint *flags, /* not const */
    2111                                 GLuint start,
    2112                                 struct gl_1d_map *map )
     2097                                GLfloat coord[][4],
     2098                                GLuint *flags, /* not const */
     2099                                GLuint start,
     2100                                struct gl_1d_map *map )
    21132101{
    21142102   const GLfloat u1 = map->u1;
    … …  
    21192107   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    21202108      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
    2121         GLfloat u = (coord[i][0] - u1) * du;
    2122         GLfloat fcolor[4];
    2123         horner_bezier_curve(map->Points, fcolor, u, 4, map->Order);
    2124         FLOAT_RGBA_TO_UBYTE_RGBA(to[i], fcolor);
    2125         flags[i+1] |= VERT_RGBA; /* reset */
     2109        GLfloat u = (coord[i][0] - u1) * du;
     2110        GLfloat fcolor[4];
     2111        horner_bezier_curve(map->Points, fcolor, u, 4, map->Order);
     2112        FLOAT_RGBA_TO_UBYTE_RGBA(to[i], fcolor);
     2113        flags[i+1] |= VERT_RGBA; /* reset */
    21262114      }
    21272115
    … …  
    21352123
    21362124static GLvector4f *eval2_obj_norm( GLvector4f *obj_ptr,
    2137                                    GLvector3f *norm_ptr,
    2138                                    GLfloat coord[][4],
    2139                                    GLuint *flags,
    2140                                    GLuint start,
    2141                                    GLuint dimension,
    2142                                    struct gl_2d_map *map )
     2125                                   GLvector3f *norm_ptr,
     2126                                   GLfloat coord[][4],
     2127                                   GLuint *flags,
     2128                                   GLuint start,
     2129                                   GLuint dimension,
     2130                                   struct gl_2d_map *map )
    21432131{
    21442132   const GLfloat u1 = map->u1;
    … …  
    21522140   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    21532141      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
    2154         GLfloat u = (coord[i][0] - u1) * du;
    2155         GLfloat v = (coord[i][1] - v1) * dv;
    2156         GLfloat du[4], dv[4];
    2157 
    2158         ASSIGN_4V(obj[i], 0,0,0,1);
    2159         de_casteljau_surf(map->Points, obj[i], du, dv, u, v, dimension,
    2160                            map->Uorder, map->Vorder);
    2161        
    2162         CROSS3(normal[i], du, dv);
    2163         NORMALIZE_3FV(normal[i]);
    2164         flags[i+1] |= VERT_NORM;
     2142        GLfloat u = (coord[i][0] - u1) * du;
     2143        GLfloat v = (coord[i][1] - v1) * dv;
     2144        GLfloat du[4], dv[4];
     2145
     2146        ASSIGN_4V(obj[i], 0,0,0,1);
     2147        de_casteljau_surf(map->Points, obj[i], du, dv, u, v, dimension,
     2148                           map->Uorder, map->Vorder);
     2149
     2150        CROSS3(normal[i], du, dv);
     2151        NORMALIZE_3FV(normal[i]);
     2152        flags[i+1] |= VERT_NORM;
    21652153      }
    21662154
    … …  
    21742162
    21752163static GLvector4f *eval2_4f( GLvector4f *dest,
    2176                              GLfloat coord[][4],
    2177                              const GLuint *flags,
    2178                              GLuint start,
    2179                              GLuint dimension,
    2180                              struct gl_2d_map *map )
     2164                             GLfloat coord[][4],
     2165                             const GLuint *flags,
     2166                             GLuint start,
     2167                             GLuint dimension,
     2168                             struct gl_2d_map *map )
    21812169{
    21822170   const GLfloat u1 = map->u1;
    … …  
    21892177   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    21902178      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
    2191         GLfloat u = (coord[i][0] - u1) * du;
    2192         GLfloat v = (coord[i][1] - v1) * dv;
    2193         horner_bezier_surf(map->Points, to[i], u, v, dimension,
    2194                             map->Uorder, map->Vorder);
     2179        GLfloat u = (coord[i][0] - u1) * du;
     2180        GLfloat v = (coord[i][1] - v1) * dv;
     2181        horner_bezier_surf(map->Points, to[i], u, v, dimension,
     2182                            map->Uorder, map->Vorder);
    21952183      }
    21962184
    … …  
    22042192
    22052193static GLvector3f *eval2_norm( GLvector3f *dest,
    2206                                GLfloat coord[][4],
    2207                                GLuint *flags,
    2208                                GLuint start,
    2209                                struct gl_2d_map *map )
     2194                               GLfloat coord[][4],
     2195                               GLuint *flags,
     2196                               GLuint start,
     2197                               struct gl_2d_map *map )
    22102198{
    22112199   const GLfloat u1 = map->u1;
    … …  
    22182206   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    22192207      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
    2220         GLfloat u = (coord[i][0] - u1) * du;
    2221         GLfloat v = (coord[i][1] - v1) * dv;
    2222         horner_bezier_surf(map->Points, to[i], u, v, 3,
    2223                             map->Uorder, map->Vorder);
    2224          flags[i+1] |= VERT_NORM; /* reset */
     2208        GLfloat u = (coord[i][0] - u1) * du;
     2209        GLfloat v = (coord[i][1] - v1) * dv;
     2210        horner_bezier_surf(map->Points, to[i], u, v, 3,
     2211                            map->Uorder, map->Vorder);
     2212         flags[i+1] |= VERT_NORM; /* reset */
    22252213     }
    22262214
    … …  
    22322220
    22332221static GLvector1ui *eval2_1ui( GLvector1ui *dest,
    2234                                GLfloat coord[][4],
    2235                                const GLuint *flags,
    2236                                GLuint start,
    2237                                struct gl_2d_map *map )
     2222                               GLfloat coord[][4],
     2223                               const GLuint *flags,
     2224                               GLuint start,
     2225                               struct gl_2d_map *map )
    22382226{
    22392227   const GLfloat u1 = map->u1;
    … …  
    22462234   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    22472235      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
    2248         GLfloat u = (coord[i][0] - u1) * du;
    2249         GLfloat v = (coord[i][1] - v1) * dv;
    2250         GLfloat tmp;
    2251         horner_bezier_surf(map->Points, &tmp, u, v, 1,
    2252                             map->Uorder, map->Vorder);
    2253 
    2254         to[i] = (GLuint) (GLint) tmp;
     2236        GLfloat u = (coord[i][0] - u1) * du;
     2237        GLfloat v = (coord[i][1] - v1) * dv;
     2238        GLfloat tmp;
     2239        horner_bezier_surf(map->Points, &tmp, u, v, 1,
     2240                            map->Uorder, map->Vorder);
     2241
     2242        to[i] = (GLuint) (GLint) tmp;
    22552243      }
    22562244
    … …  
    22632251
    22642252static GLvector4ub *eval2_color( GLvector4ub *dest,
    2265                                 GLfloat coord[][4],
    2266                                 GLuint *flags,
    2267                                 GLuint start,
    2268                                 struct gl_2d_map *map )
     2253                                GLfloat coord[][4],
     2254                                GLuint *flags,
     2255                                GLuint start,
     2256                                struct gl_2d_map *map )
    22692257{
    22702258   const GLfloat u1 = map->u1;
    … …  
    22772265   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
    22782266      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
    2279         GLfloat u = (coord[i][0] - u1) * du;
    2280         GLfloat v = (coord[i][1] - v1) * dv;
    2281         GLfloat fcolor[4];
    2282         horner_bezier_surf(map->Points, fcolor, u, v, 4,
    2283                             map->Uorder, map->Vorder);
    2284         FLOAT_RGBA_TO_UBYTE_RGBA(to[i], fcolor);
    2285         flags[i+1] |= VERT_RGBA; /* reset */
     2267        GLfloat u = (coord[i][0] - u1) * du;
     2268        GLfloat v = (coord[i][1] - v1) * dv;
     2269        GLfloat fcolor[4];
     2270        horner_bezier_surf(map->Points, fcolor, u, v, 4,
     2271                            map->Uorder, map->Vorder);
     2272        FLOAT_RGBA_TO_UBYTE_RGBA(to[i], fcolor);
     2273        flags[i+1] |= VERT_RGBA; /* reset */
    22862274      }
    22872275
    … …  
    22932281
    22942282static GLvector4f *copy_4f( GLvector4f *out, CONST GLvector4f *in,
    2295                             const GLuint *flags,
    2296                             GLuint start )
     2283                            const GLuint *flags,
     2284                            GLuint start )
    22972285{
    22982286   GLfloat (*to)[4] = out->data;
    … …  
    23022290   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++)
    23032291      if (!(flags[i] & VERT_EVAL_ANY))
    2304         COPY_4FV( to[i], from[i] );
     2292        COPY_4FV( to[i], from[i] );
    23052293
    23062294   out->start = VEC_ELT(out, GLfloat, start);
    … …  
    23092297
    23102298static GLvector3f *copy_3f( GLvector3f *out, CONST GLvector3f *in,
    2311                             const GLuint *flags,
    2312                             GLuint start )
     2299                            const GLuint *flags,
     2300                            GLuint start )
    23132301{
    23142302   GLfloat (*to)[3] = out->data;
    … …  
    23182306   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++)
    23192307      if (!(flags[i] & VERT_EVAL_ANY))
    2320         COPY_3V( to[i], from[i] );
     2308        COPY_3V( to[i], from[i] );
    23212309
    23222310   out->start = VEC_ELT(out, GLfloat, start);
    … …  
    23252313
    23262314static GLvector4ub *copy_4ub( GLvector4ub *out,
    2327                               CONST GLvector4ub *in,
    2328                               const GLuint *flags,
    2329                               GLuint start )
     2315                              CONST GLvector4ub *in,
     2316                              const GLuint *flags,
     2317                              GLuint start )
    23302318{
    23312319   GLubyte (*to)[4] = out->data;
    … …  
    23352323   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++)
    23362324      if (!(flags[i] & VERT_EVAL_ANY))
    2337         COPY_4UBV( to[i], from[i] );
     2325        COPY_4UBV( to[i], from[i] );
    23382326
    23392327   out->start = VEC_ELT(out, GLubyte, start);
    … …  
    23422330
    23432331static GLvector1ui *copy_1ui( GLvector1ui *out,
    2344                               CONST GLvector1ui *in,
    2345                               const GLuint *flags,
    2346                               GLuint start )
     2332                              CONST GLvector1ui *in,
     2333                              const GLuint *flags,
     2334                              GLuint start )
    23472335{
    23482336   GLuint *to = out->data;
    … …  
    23522340   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++)
    23532341      if (!(flags[i] & VERT_EVAL_ANY))
    2354         to[i] = from[i];
     2342        to[i] = from[i];
    23552343
    23562344   out->start = VEC_ELT(out, GLuint, start);
    … …  
    24192407   {
    24202408      eval_points1( IM->Obj, coord, flags, IM->Start,
    2421                     ctx->Eval.MapGrid1du,
    2422                     ctx->Eval.MapGrid1u1);
     2409                    ctx->Eval.MapGrid1du,
     2410                    ctx->Eval.MapGrid1u1);
    24232411
    24242412      coord = IM->Obj;
    … …  
    24282416   {
    24292417      eval_points2( IM->Obj, coord, flags, IM->Start,
    2430                     ctx->Eval.MapGrid2du,
    2431                     ctx->Eval.MapGrid2u1,
    2432                     ctx->Eval.MapGrid2dv,
    2433                     ctx->Eval.MapGrid2v1 );
     2418                    ctx->Eval.MapGrid2du,
     2419                    ctx->Eval.MapGrid2u1,
     2420                    ctx->Eval.MapGrid2dv,
     2421                    ctx->Eval.MapGrid2v1 );
    24342422
    24352423      coord = IM->Obj;
    … …  
    24442432
    24452433      if (ctx->Eval.Map1Index && any_eval1)
    2446         VB->IndexPtr = eval1_1ui( out_index, coord, flags, IM->Start,
    2447                                    &ctx->EvalMap.Map1Index );
     2434        VB->IndexPtr = eval1_1ui( out_index, coord, flags, IM->Start,
     2435                                   &ctx->EvalMap.Map1Index );
    24482436
    24492437      if (ctx->Eval.Map2Index && any_eval2)
    2450         VB->IndexPtr = eval2_1ui( out_index, coord, flags, IM->Start,
    2451                                    &ctx->EvalMap.Map2Index );
    2452        
     2438        VB->IndexPtr = eval2_1ui( out_index, coord, flags, IM->Start,
     2439                                   &ctx->EvalMap.Map2Index );
     2440
    24532441      if (VB->IndexPtr != in_index) {
    2454         new_flags |= VERT_INDEX;
    2455         if (!all_eval)
    2456             VB->IndexPtr = copy_1ui( out_index, in_index, flags, IM->Start );
     2442        new_flags |= VERT_INDEX;
     2443        if (!all_eval)
     2444            VB->IndexPtr = copy_1ui( out_index, in_index, flags, IM->Start );
    24572445      }
    24582446   }
    … …  
    24642452
    24652453      if (ctx->Eval.Map1Color4 && any_eval1)
    2466         VB->ColorPtr = eval1_color( out_color, coord, flags, IM->Start,
    2467                                    &ctx->EvalMap.Map1Color4 );
     2454        VB->ColorPtr = eval1_color( out_color, coord, flags, IM->Start,
     2455                                   &ctx->EvalMap.Map1Color4 );
    24682456
    24692457      if (ctx->Eval.Map2Color4 && any_eval2)
    2470         VB->ColorPtr = eval2_color( out_color, coord, flags, IM->Start,
    2471                                      &ctx->EvalMap.Map2Color4 );
    2472        
     2458        VB->ColorPtr = eval2_color( out_color, coord, flags, IM->Start,
     2459                                     &ctx->EvalMap.Map2Color4 );
     2460
    24732461      if (VB->ColorPtr != in_color) {
    2474         new_flags |= VERT_RGBA;
    2475         if (!all_eval)
    2476             VB->ColorPtr = copy_4ub( out_color, in_color, flags, IM->Start );
     2462        new_flags |= VERT_RGBA;
     2463        if (!all_eval)
     2464            VB->ColorPtr = copy_4ub( out_color, in_color, flags, IM->Start );
    24772465      }
    24782466
    … …  
    24872475
    24882476      if (ctx->Eval.Map1Normal && any_eval1)
    2489         VB->NormalPtr = eval1_norm( out_normal, coord, flags, IM->Start,
    2490                                      &ctx->EvalMap.Map1Normal );
     2477        VB->NormalPtr = eval1_norm( out_normal, coord, flags, IM->Start,
     2478                                     &ctx->EvalMap.Map1Normal );
    24912479
    24922480      if (ctx->Eval.Map2Normal && any_eval2)
    2493         VB->NormalPtr = eval2_norm( out_normal, coord, flags, IM->Start,
    2494                                      &ctx->EvalMap.Map2Normal );
    2495        
     2481        VB->NormalPtr = eval2_norm( out_normal, coord, flags, IM->Start,
     2482                                     &ctx->EvalMap.Map2Normal );
     2483
    24962484      if (VB->NormalPtr != in_normal) {
    2497         new_flags |= VERT_NORM;
    2498         if (!all_eval)
    2499             VB->NormalPtr = copy_3f( out_normal, in_normal, flags, IM->Start );
     2485        new_flags |= VERT_NORM;
     2486        if (!all_eval)
     2487            VB->NormalPtr = copy_3f( out_normal, in_normal, flags, IM->Start );
    25002488      }
    25012489   }
    … …  
    25092497
    25102498      if (any_eval1) {
    2511         if (ctx->Eval.Map1TextureCoord4)
    2512             tc = eval1_4f( out, coord, flags, IM->Start,
    2513                            4, &ctx->EvalMap.Map1Texture4);
    2514         else if (ctx->Eval.Map1TextureCoord3)
    2515             tc = eval1_4f( out, coord, flags, IM->Start, 3,
    2516                            &ctx->EvalMap.Map1Texture3);
    2517         else if (ctx->Eval.Map1TextureCoord2)
    2518             tc = eval1_4f( out, coord, flags, IM->Start, 2,
    2519                            &ctx->EvalMap.Map1Texture2);
    2520         else if (ctx->Eval.Map1TextureCoord1)
    2521             tc = eval1_4f( out, coord, flags, IM->Start, 1,
    2522                            &ctx->EvalMap.Map1Texture1);
     2499        if (ctx->Eval.Map1TextureCoord4)
     2500            tc = eval1_4f( out, coord, flags, IM->Start,
     2501                           4, &ctx->EvalMap.Map1Texture4);
     2502        else if (ctx->Eval.Map1TextureCoord3)
     2503            tc = eval1_4f( out, coord, flags, IM->Start, 3,
     2504                           &ctx->EvalMap.Map1Texture3);
     2505        else if (ctx->Eval.Map1TextureCoord2)
     2506            tc = eval1_4f( out, coord, flags, IM->Start, 2,
     2507                           &ctx->EvalMap.Map1Texture2);
     2508        else if (ctx->Eval.Map1TextureCoord1)
     2509            tc = eval1_4f( out, coord, flags, IM->Start, 1,
     2510                           &ctx->EvalMap.Map1Texture1);
    25232511      }
    25242512
    25252513      if (any_eval2) {
    2526         if (ctx->Eval.Map2TextureCoord4)
    2527             tc = eval2_4f( out, coord, flags, IM->Start,
    2528                            4, &ctx->EvalMap.Map2Texture4);
    2529         else if (ctx->Eval.Map2TextureCoord3)
    2530             tc = eval2_4f( out, coord, flags, IM->Start,
    2531                            3, &ctx->EvalMap.Map2Texture3);
    2532         else if (ctx->Eval.Map2TextureCoord2)
    2533             tc = eval2_4f( out, coord, flags, IM->Start,
    2534                            2, &ctx->EvalMap.Map2Texture2);
    2535         else if (ctx->Eval.Map2TextureCoord1)
    2536             tc = eval2_4f( out, coord, flags, IM->Start,
    2537                            1, &ctx->EvalMap.Map2Texture1);
     2514        if (ctx->Eval.Map2TextureCoord4)
     2515            tc = eval2_4f( out, coord, flags, IM->Start,
     2516                           4, &ctx->EvalMap.Map2Texture4);
     2517        else if (ctx->Eval.Map2TextureCoord3)
     2518            tc = eval2_4f( out, coord, flags, IM->Start,
     2519                           3, &ctx->EvalMap.Map2Texture3);
     2520        else if (ctx->Eval.Map2TextureCoord2)
     2521            tc = eval2_4f( out, coord, flags, IM->Start,
     2522                           2, &ctx->EvalMap.Map2Texture2);
     2523        else if (ctx->Eval.Map2TextureCoord1)
     2524            tc = eval2_4f( out, coord, flags, IM->Start,
     2525                           1, &ctx->EvalMap.Map2Texture1);
    25382526      }
    25392527
    25402528      if (tc != in) {
    2541         new_flags |= VERT_TEX_ANY(0); /* fix for sizes.. */
    2542         if (!all_eval)
    2543             tc = copy_4f( out, in, flags, IM->Start );
     2529        new_flags |= VERT_TEX_ANY(0); /* fix for sizes.. */
     2530        if (!all_eval)
     2531            tc = copy_4f( out, in, flags, IM->Start );
    25442532      }
    25452533
    … …  
    25542542
    25552543      if (any_eval1) {
    2556         if (ctx->Eval.Map1Vertex4)
    2557             obj = eval1_4f( out, coord, flags, IM->Start,
    2558                             4, &ctx->EvalMap.Map1Vertex4);
    2559         else
    2560             obj = eval1_4f( out, coord, flags, IM->Start,
    2561                             3, &ctx->EvalMap.Map1Vertex3);
     2544        if (ctx->Eval.Map1Vertex4)
     2545            obj = eval1_4f( out, coord, flags, IM->Start,
     2546                            4, &ctx->EvalMap.Map1Vertex4);
     2547        else
     2548            obj = eval1_4f( out, coord, flags, IM->Start,
     2549                            3, &ctx->EvalMap.Map1Vertex3);
    25622550      }
    25632551
    25642552      if (any_eval2) {
    2565         if (ctx->Eval.Map2Vertex4)
    2566         {
    2567             if (ctx->Eval.AutoNormal && (req & VERT_NORM))
    2568                obj = eval2_obj_norm( out, VB->NormalPtr, coord, flags, IM->Start,
    2569                                      4, &ctx->EvalMap.Map2Vertex4 );
    2570             else
    2571                obj = eval2_4f( out, coord, flags, IM->Start,
    2572                                4, &ctx->EvalMap.Map2Vertex4);
    2573         }
    2574         else if (ctx->Eval.Map2Vertex3)
    2575         {
    2576             if (ctx->Eval.AutoNormal && (req & VERT_NORM))
    2577                obj = eval2_obj_norm( out, VB->NormalPtr, coord, flags, IM->Start,
    2578                                      3, &ctx->EvalMap.Map2Vertex3 );
    2579             else
    2580                obj = eval2_4f( out, coord, flags, IM->Start,
    2581                                3, &ctx->EvalMap.Map2Vertex3 );
    2582         }
     2553        if (ctx->Eval.Map2Vertex4)
     2554        {
     2555            if (ctx->Eval.AutoNormal && (req & VERT_NORM))
     2556               obj = eval2_obj_norm( out, VB->NormalPtr, coord, flags, IM->Start,
     2557                                     4, &ctx->EvalMap.Map2Vertex4 );
     2558            else
     2559               obj = eval2_4f( out, coord, flags, IM->Start,
     2560                               4, &ctx->EvalMap.Map2Vertex4);
     2561        }
     2562        else if (ctx->Eval.Map2Vertex3)
     2563        {
     2564            if (ctx->Eval.AutoNormal && (req & VERT_NORM))
     2565               obj = eval2_obj_norm( out, VB->NormalPtr, coord, flags, IM->Start,
     2566                                     3, &ctx->EvalMap.Map2Vertex3 );
     2567            else
     2568               obj = eval2_4f( out, coord, flags, IM->Start,
     2569                               3, &ctx->EvalMap.Map2Vertex3 );
     2570        }
    25832571      }
    25842572
    25852573      if (obj != in && !all_eval)
    2586         obj = copy_4f( out, in, flags, IM->Start );
     2574        obj = copy_4f( out, in, flags, IM->Start );
    25872575
    25882576      VB->ObjPtr = obj;
    … …  
    25962584
    25972585      if (!flags) {
    2598         VB->EvaluatedFlags = (GLuint *) MALLOC(VB->Size * sizeof(GLuint));
    2599         flags = VB->Flag = VB->EvaluatedFlags;
     2586        VB->EvaluatedFlags = (GLuint *) MALLOC(VB->Size * sizeof(GLuint));
     2587        flags = VB->Flag = VB->EvaluatedFlags;
    26002588      }
    26012589
    26022590      if (all_eval) {
    2603         for (i = 0 ; i < count ; i++)
    2604             flags[i] = oldflags[i] | new_flags;
     2591        for (i = 0 ; i < count ; i++)
     2592            flags[i] = oldflags[i] | new_flags;
    26052593      } else {
    2606          GLuint andflag = ~0;
    2607          for (i = 0 ; i < count ; i++) {
    2608             if (oldflags[i] & VERT_EVAL_ANY)
    2609                flags[i] = oldflags[i] | new_flags;
    2610             andflag &= flags[i];
    2611          }
    2612       }
    2613    }
    2614 }
    2615 
    2616 
    2617 void gl_MapGrid1f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2 )
    2618 {
     2594         GLuint andflag = ~0;
     2595         for (i = 0 ; i < count ; i++) {
     2596            if (oldflags[i] & VERT_EVAL_ANY)
     2597               flags[i] = oldflags[i] | new_flags;
     2598            andflag &= flags[i];
     2599         }
     2600      }
     2601   }
     2602}
     2603
     2604
     2605void
     2606_mesa_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
     2607{
     2608   GET_CURRENT_CONTEXT(ctx);
    26192609   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMapGrid1f");
    26202610
    … …  
    26302620
    26312621
    2632 void gl_MapGrid2f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2,
    2633                   GLint vn, GLfloat v1, GLfloat v2 )
    2634 {
     2622void
     2623_mesa_MapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
     2624{
     2625   _mesa_MapGrid1f( un, u1, u2 );
     2626}
     2627
     2628
     2629void
     2630_mesa_MapGrid2f( GLint un, GLfloat u1, GLfloat u2,
     2631                 GLint vn, GLfloat v1, GLfloat v2 )
     2632{
     2633   GET_CURRENT_CONTEXT(ctx);
    26352634   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glMapGrid2f");
    26362635   if (un<1) {
    … …  
    26532652
    26542653
    2655 
    2656 void gl_EvalMesh1( GLcontext* ctx, GLenum mode, GLint i1, GLint i2 )
    2657 {
     2654void
     2655_mesa_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
     2656                 GLint vn, GLdouble v1, GLdouble v2 )
     2657{
     2658   _mesa_MapGrid2f( un, u1, u2, vn, v1, v2 );
     2659}
     2660
     2661
     2662
     2663
     2664/* KW: If are compiling, we don't know whether eval will produce a
     2665 *     vertex when it is run in the future.  If this is pure immediate
     2666 *     mode, eval is a noop if neither vertex map is enabled.
     2667 *
     2668 *     Thus we need to have a check in the display list code or
     2669 *     elsewhere for eval(1,2) vertices in the case where
     2670 *     map(1,2)_vertex is disabled, and to purge those vertices from
     2671 *     the vb.  This is currently done
     2672 *     via  modifications to the cull_vb and render_vb operations, and
     2673 *     by using the existing cullmask mechanism for all other operations.
     2674 */
     2675
     2676
     2677/* KW: Because the eval values don't become 'current', fixup will flow
     2678 *     through these vertices, and then evaluation will write on top
     2679 *     of the fixup results.
     2680 *
     2681 *     This is a little inefficient, but at least it is correct.  This
     2682 *     could be short-circuited in the case where all vertices are
     2683 *     eval-vertices, or more generally by a cullmask in fixup.
     2684 *
     2685 *     Note: using Obj to hold eval coord data.  This data is actually
     2686 *     transformed if eval is disabled.  But disabling eval & sending
     2687 *     eval coords is stupid, right?
     2688 */
     2689
     2690
     2691#define EVALCOORD1(IM, x)                               \
     2692{                                                       \
     2693   GLuint count = IM->Count++;                          \
     2694   IM->Flag[count] |= VERT_EVAL_C1;                     \
     2695   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);               \
     2696   if (count == VB_MAX-1)                               \
     2697      IM->maybe_transform_vb( IM );                     \
     2698}
     2699
     2700#define EVALCOORD2(IM, x, y)                            \
     2701{                                                       \
     2702   GLuint count = IM->Count++;                          \
     2703   IM->Flag[count] |= VERT_EVAL_C2;                     \
     2704   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);               \
     2705   if (count == VB_MAX-1)                               \
     2706      IM->maybe_transform_vb( IM );                     \
     2707}
     2708
     2709#define EVALPOINT1(IM, x)                               \
     2710{                                                       \
     2711   GLuint count = IM->Count++;                          \
     2712   IM->Flag[count] |= VERT_EVAL_P1;                     \
     2713   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);               \
     2714   if (count == VB_MAX-1)                               \
     2715      IM->maybe_transform_vb( IM );                     \
     2716}
     2717
     2718#define EVALPOINT2(IM, x, y)                            \
     2719{                                                       \
     2720   GLuint count = IM->Count++;                          \
     2721   IM->Flag[count] |= VERT_EVAL_P2;                     \
     2722   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);               \
     2723   if (count == VB_MAX-1)                               \
     2724      IM->maybe_transform_vb( IM );                     \
     2725}
     2726
     2727
     2728/* Lame internal function:
     2729 */
     2730static void
     2731eval_coord1f( GLcontext *CC, GLfloat u )
     2732{
     2733   struct immediate *i = CC->input;
     2734   EVALCOORD1( i, u );
     2735}
     2736
     2737
     2738void
     2739_mesa_EvalCoord1d( GLdouble u )
     2740{
     2741   GET_IMMEDIATE;
     2742   EVALCOORD1( IM, (GLfloat) u );
     2743}
     2744
     2745
     2746void
     2747_mesa_EvalCoord1f( GLfloat u )
     2748{
     2749   GET_IMMEDIATE;
     2750   EVALCOORD1( IM, u );
     2751}
     2752
     2753
     2754void
     2755_mesa_EvalCoord1dv( const GLdouble *u )
     2756{
     2757   GET_IMMEDIATE;
     2758   EVALCOORD1( IM, (GLfloat) *u );
     2759}
     2760
     2761
     2762void
     2763_mesa_EvalCoord1fv( const GLfloat *u )
     2764{
     2765   GET_IMMEDIATE;
     2766   EVALCOORD1( IM, (GLfloat) *u );
     2767}
     2768
     2769
     2770void
     2771_mesa_EvalCoord2d( GLdouble u, GLdouble v )
     2772{
     2773   GET_IMMEDIATE;
     2774   EVALCOORD2( IM, (GLfloat) u, (GLfloat) v );
     2775}
     2776
     2777
     2778void
     2779_mesa_EvalCoord2f( GLfloat u, GLfloat v )
     2780{
     2781   GET_IMMEDIATE;
     2782   EVALCOORD2( IM, u, v );
     2783}
     2784
     2785
     2786/* Lame internal function:
     2787 */
     2788static void
     2789eval_coord2f( GLcontext *CC, GLfloat u, GLfloat v )
     2790{
     2791   struct immediate *i = CC->input;
     2792   EVALCOORD2( i, u, v );
     2793}
     2794
     2795
     2796void
     2797_mesa_EvalCoord2dv( const GLdouble *u )
     2798{
     2799   GET_IMMEDIATE;
     2800   EVALCOORD2( IM, (GLfloat) u[0], (GLfloat) u[1] );
     2801}
     2802
     2803
     2804void
     2805_mesa_EvalCoord2fv( const GLfloat *u )
     2806{
     2807   GET_IMMEDIATE;
     2808   EVALCOORD2( IM, u[0], u[1] );
     2809}
     2810
     2811
     2812void
     2813_mesa_EvalPoint1( GLint i )
     2814{
     2815   GET_IMMEDIATE;
     2816   EVALPOINT1( IM, i );
     2817}
     2818
     2819
     2820void
     2821_mesa_EvalPoint2( GLint i, GLint j )
     2822{
     2823   GET_IMMEDIATE;
     2824   EVALPOINT2( IM, i, j );
     2825}
     2826
     2827
     2828
     2829
     2830
     2831void
     2832_mesa_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
     2833{
     2834   GET_CURRENT_CONTEXT(ctx);
    26582835   GLint i;
    26592836   GLfloat u, du;
    … …  
    26882865   gl_Begin( ctx, prim );
    26892866   for (i=i1;i<=i2;i++,u+=du) {
    2690       gl_EvalCoord1f( ctx, u );
     2867      eval_coord1f( ctx, u );
    26912868   }
    26922869   gl_End(ctx);
    … …  
    26952872
    26962873
    2697 void gl_EvalMesh2( GLcontext* ctx,
    2698                    GLenum mode,
    2699                    GLint i1, GLint i2,
    2700                    GLint j1, GLint j2 )
    2701 {
     2874void
     2875_mesa_EvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
     2876{
     2877   GET_CURRENT_CONTEXT(ctx);
    27022878   GLint i, j;
    27032879   GLfloat u, du, v, dv, v1, u1;
    … …  
    27212897      gl_Begin( ctx, GL_POINTS );
    27222898      for (v=v1,j=j1;j<=j2;j++,v+=dv) {
    2723         for (u=u1,i=i1;i<=i2;i++,u+=du) {
    2724             gl_EvalCoord2f( ctx, u, v );
    2725         }
     2899        for (u=u1,i=i1;i<=i2;i++,u+=du) {
     2900            eval_coord2f( ctx, u, v );
     2901        }
    27262902      }
    27272903      gl_End(ctx);
    … …  
    27292905   case GL_LINE:
    27302906      for (v=v1,j=j1;j<=j2;j++,v+=dv) {
    2731         gl_Begin( ctx, GL_LINE_STRIP );
    2732         for (u=u1,i=i1;i<=i2;i++,u+=du) {
    2733             gl_EvalCoord2f( ctx, u, v );
    2734         }
    2735         gl_End(ctx);
     2907        gl_Begin( ctx, GL_LINE_STRIP );
     2908        for (u=u1,i=i1;i<=i2;i++,u+=du) {
     2909            eval_coord2f( ctx, u, v );
     2910        }
     2911        gl_End(ctx);
    27362912      }
    27372913      for (u=u1,i=i1;i<=i2;i++,u+=du) {
    2738         gl_Begin( ctx, GL_LINE_STRIP );
    2739         for (v=v1,j=j1;j<=j2;j++,v+=dv) {
    2740             gl_EvalCoord2f( ctx, u, v );
    2741         }
    2742         gl_End(ctx);
     2914        gl_Begin( ctx, GL_LINE_STRIP );
     2915        for (v=v1,j=j1;j<=j2;j++,v+=dv) {
     2916            eval_coord2f( ctx, u, v );
     2917        }
     2918        gl_End(ctx);
    27432919      }
    27442920      break;
    27452921   case GL_FILL:
    27462922      for (v=v1,j=j1;j<j2;j++,v+=dv) {
    2747         /* NOTE: a quad strip can't be used because the four */
    2748         /* can't be guaranteed to be coplanar! */
    2749         gl_Begin( ctx, GL_TRIANGLE_STRIP );
    2750         for (u=u1,i=i1;i<=i2;i++,u+=du) {
    2751             gl_EvalCoord2f( ctx, u, v );
    2752             gl_EvalCoord2f( ctx, u, v+dv );
    2753         }
    2754         gl_End(ctx);
     2923        /* NOTE: a quad strip can't be used because the four */
     2924        /* can't be guaranteed to be coplanar! */
     2925        gl_Begin( ctx, GL_TRIANGLE_STRIP );
     2926        for (u=u1,i=i1;i<=i2;i++,u+=du) {
     2927            eval_coord2f( ctx, u, v );
     2928            eval_coord2f( ctx, u, v+dv );
     2929        }
     2930        gl_End(ctx);
    27552931      }
    27562932      break;
Note: See TracChangeset for help on using the changeset viewer.