home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / System / Mesa-3.1 / src / api1.c < prev    next >
C/C++ Source or Header  |  2000-01-07  |  46KB  |  2,059 lines
  1. /* $Id: api1.c,v 1.9.2.1 1999/11/25 16:51:24 keithw Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.1
  6.  * 
  7.  * Copyright (C) 1999  Brian Paul   All Rights Reserved.
  8.  * 
  9.  * Permission is hereby granted, free of charge, to any person obtaining a
  10.  * copy of this software and associated documentation files (the "Software"),
  11.  * to deal in the Software without restriction, including without limitation
  12.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13.  * and/or sell copies of the Software, and to permit persons to whom the
  14.  * Software is furnished to do so, subject to the following conditions:
  15.  * 
  16.  * The above copyright notice and this permission notice shall be included
  17.  * in all copies or substantial portions of the Software.
  18.  * 
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  */
  26.  
  27.  
  28.  
  29.  
  30. #ifdef PC_HEADER
  31. #include "all.h"
  32. #else
  33. #ifndef XFree86Server
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #else
  37. #include "GL/xf86glx.h"
  38. #endif
  39. #include "api.h"
  40. #include "bitmap.h"
  41. #include "context.h"
  42. #include "drawpix.h"
  43. #include "eval.h"
  44. #include "image.h"
  45. #include "light.h"
  46. #include "macros.h"
  47. #include "matrix.h"
  48. #include "mmath.h"
  49. #include "teximage.h"
  50. #include "types.h"
  51. #include "varray.h"
  52. #include "vb.h"
  53. #include "vbfill.h"
  54. #endif
  55.  
  56. /*
  57.  * Part 1 of API functions
  58.  */
  59.  
  60. void GLAPIENTRY glAccum(CTX_ARG GLenum op, GLfloat value )
  61. {
  62.    GET_CONTEXT;
  63.    CHECK_CONTEXT;
  64.    (*CC->API.Accum)(CC, op, value);
  65. }
  66.  
  67.  
  68. void GLAPIENTRY glAlphaFunc(CTX_ARG GLenum func, GLclampf ref )
  69. {
  70.    GET_CONTEXT;
  71.    CHECK_CONTEXT;
  72.    (*CC->API.AlphaFunc)(CC, func, ref);
  73. }
  74.  
  75.  
  76. GLboolean GLAPIENTRY glAreTexturesResident(CTX_ARG GLsizei n, const GLuint *textures,
  77.                                             GLboolean *residences )
  78. {
  79.    GET_CONTEXT;
  80.    CHECK_CONTEXT_RETURN(GL_FALSE);
  81.    return (*CC->API.AreTexturesResident)(CC, n, textures, residences);
  82. }
  83.  
  84. /* Enough funny business going on in here it might be quicker to use a
  85.  * function pointer.
  86.  */
  87. #define ARRAY_ELT( IM, i )                    \
  88. {                                \
  89.    GLuint count = IM->Count;                    \
  90.    IM->Elt[count] = i;                        \
  91.    IM->Flag[count] = ((IM->Flag[count] & IM->ArrayAndFlags) |    \
  92.               VERT_ELT);                \
  93.    IM->FlushElt |= IM->ArrayEltFlush;                \
  94.    IM->Count = count += IM->ArrayIncr;                \
  95.    if (count == VB_MAX)                        \
  96.       IM->maybe_transform_vb( IM );                \
  97. }
  98.  
  99.  
  100. void GLAPIENTRY glArrayElement(CTX_ARG GLint i )
  101. {
  102.    GET_IMMEDIATE;
  103.    ARRAY_ELT( IM, i );
  104. }
  105.  
  106.  
  107. void GLAPIENTRY glArrayElementEXT(CTX_ARG GLint i )
  108. {
  109.    GET_IMMEDIATE;
  110.    ARRAY_ELT( IM, i );
  111. }
  112.  
  113.  
  114. void gl_ArrayElement( GLcontext *CC, GLint i )
  115. {
  116.    struct immediate *im = CC->input;
  117.    ARRAY_ELT( im, i );
  118. }
  119.  
  120.  
  121. void GLAPIENTRY glBegin(CTX_ARG GLenum mode )
  122. {
  123.    GET_CONTEXT;
  124.  
  125.    if (mode < GL_POINTS || mode > GL_POLYGON) {
  126.       gl_compile_error( CC, GL_INVALID_ENUM, "glBegin" );
  127.       return;             
  128.    }
  129.  
  130.    gl_Begin(CC,mode);
  131. }
  132.  
  133.  
  134. void GLAPIENTRY glBindTexture(CTX_ARG GLenum target, GLuint texture )
  135. {
  136.    GET_CONTEXT;
  137.    CHECK_CONTEXT;
  138.    (*CC->API.BindTexture)(CC, target, texture);
  139. }
  140.  
  141.  
  142. void GLAPIENTRY glBitmap(CTX_ARG  GLsizei width, GLsizei height,
  143.                          GLfloat xorig, GLfloat yorig,
  144.                          GLfloat xmove, GLfloat ymove,
  145.                          const GLubyte *bitmap )
  146. {
  147.    GET_CONTEXT;
  148.    CHECK_CONTEXT;
  149.    (*CC->API.Bitmap)( CC, width, height, xorig, yorig, xmove, ymove, bitmap,
  150.                       &CC->Unpack );
  151. }
  152.  
  153.  
  154. void GLAPIENTRY glBlendFunc(CTX_ARG GLenum sfactor, GLenum dfactor )
  155. {
  156.    GET_CONTEXT;
  157.    CHECK_CONTEXT;
  158.    (*CC->API.BlendFunc)(CC, sfactor, dfactor);
  159. }
  160.  
  161.  
  162. void GLAPIENTRY glCallList(CTX_ARG GLuint list )
  163. {
  164.    GET_CONTEXT;
  165.    CHECK_CONTEXT;
  166.    (*CC->API.CallList)(CC, list);
  167. }
  168.  
  169.  
  170. void GLAPIENTRY glCallLists(CTX_ARG GLsizei n, GLenum type, const GLvoid *lists )
  171. {
  172.    GET_CONTEXT;
  173.    CHECK_CONTEXT;
  174.    (*CC->API.CallLists)(CC, n, type, lists);
  175. }
  176.  
  177.  
  178. void GLAPIENTRY glClear(CTX_ARG GLbitfield mask )
  179. {
  180.    GET_CONTEXT;
  181.    CHECK_CONTEXT;
  182.    (*CC->API.Clear)(CC, mask);
  183. }
  184.  
  185.  
  186. void GLAPIENTRY glClearAccum(CTX_ARG GLfloat red, GLfloat green,
  187.                               GLfloat blue, GLfloat alpha )
  188. {
  189.    GET_CONTEXT;
  190.    CHECK_CONTEXT;
  191.    (*CC->API.ClearAccum)(CC, red, green, blue, alpha);
  192. }
  193.  
  194.  
  195.  
  196. void GLAPIENTRY glClearIndex(CTX_ARG GLfloat c )
  197. {
  198.    GET_CONTEXT;
  199.    CHECK_CONTEXT;
  200.    (*CC->API.ClearIndex)(CC, c);
  201. }
  202.  
  203.  
  204. void GLAPIENTRY glClearColor(CTX_ARG GLclampf red, GLclampf green,
  205.                               GLclampf blue, GLclampf alpha )
  206. {
  207.    GET_CONTEXT;
  208.    CHECK_CONTEXT;
  209.    (*CC->API.ClearColor)(CC, red, green, blue, alpha);
  210. }
  211.  
  212.  
  213. void GLAPIENTRY glClearDepth(CTX_ARG GLclampd depth )
  214. {
  215.    GET_CONTEXT;
  216.    CHECK_CONTEXT;
  217.    (*CC->API.ClearDepth)( CC, depth );
  218. }
  219.  
  220.  
  221. void GLAPIENTRY glClearStencil(CTX_ARG GLint s )
  222. {
  223.    GET_CONTEXT;
  224.    CHECK_CONTEXT;
  225.    (*CC->API.ClearStencil)(CC, s);
  226. }
  227.  
  228.  
  229. void GLAPIENTRY glClipPlane(CTX_ARG GLenum plane, const GLdouble *equation )
  230. {
  231.    GLfloat eq[4];
  232.    GET_CONTEXT;
  233.    CHECK_CONTEXT;
  234.    eq[0] = (GLfloat) equation[0];
  235.    eq[1] = (GLfloat) equation[1];
  236.    eq[2] = (GLfloat) equation[2];
  237.    eq[3] = (GLfloat) equation[3];
  238.    (*CC->API.ClipPlane)(CC, plane, eq );
  239. }
  240.  
  241.  
  242. /* KW: Again, a stateless implementation of these functions.  The big
  243.  * news here is the impact on color material.  This was previously
  244.  * handled by swaping the function pointers that these API's used to
  245.  * call.  This is no longer possible, and we have to pick up the
  246.  * pieces later on and make them work with either color-color, or
  247.  * color-material.
  248.  *
  249.  * But in truth, this is not a bad thing, because it was necessary
  250.  * to implement that mechanism to get good performance from
  251.  * color-material and vertex arrays.  
  252.  */
  253. #define COLOR( IM, r,g,b,a )            \
  254. {                        \
  255.    GLuint count = IM->Count;            \
  256.    IM->Flag[count] |= VERT_RGBA;        \
  257.    IM->Color[count][0] = r;            \
  258.    IM->Color[count][1] = g;            \
  259.    IM->Color[count][2] = b;            \
  260.    IM->Color[count][3] = a;            \
  261. }
  262.  
  263. #if 0
  264. #define COLOR4F( IM, r,g,b,a )                \
  265. {                            \
  266.    GLuint count = IM->Count;                \
  267.    IM->Flag[count] |= VERT_RGBA | VERT_FLOAT_RGBA;    \
  268.    IM->FloatColor[count][0] = r;            \
  269.    IM->FloatColor[count][1] = g;            \
  270.    IM->FloatColor[count][2] = b;            \
  271.    IM->FloatColor[count][3] = a;            \
  272. }
  273. #else
  274. #define COLOR4F(IM, r, g, b, a)            \
  275. {                        \
  276.    GLubyte col[4];                \
  277.    FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);    \
  278.    FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);    \
  279.    FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);    \
  280.    FLOAT_COLOR_TO_UBYTE_COLOR(col[3], a);    \
  281.    COLORV( IM, col );                \
  282. }
  283. #endif
  284.  
  285.  
  286.  
  287. #define COLORV( IM, v )                \
  288. {                        \
  289.    GLuint count = IM->Count;            \
  290.    IM->Flag[count] |= VERT_RGBA;        \
  291.    COPY_4UBV(IM->Color[count], v);        \
  292. }
  293.  
  294.  
  295. void GLAPIENTRY glColor3b(CTX_ARG GLbyte red, GLbyte green, GLbyte blue )
  296. {
  297.    GET_IMMEDIATE;
  298.    COLOR( IM, 
  299.       BYTE_TO_UBYTE(red), 
  300.       BYTE_TO_UBYTE(green),
  301.       BYTE_TO_UBYTE(blue),
  302.       255 );
  303. }
  304.  
  305.  
  306. void GLAPIENTRY glColor3d(CTX_ARG GLdouble red, GLdouble green, GLdouble blue )
  307. {
  308.    GLubyte col[4];
  309.    GLfloat r = red;
  310.    GLfloat g = green;
  311.    GLfloat b = blue;
  312.    GET_IMMEDIATE;
  313.    FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
  314.    FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
  315.    FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
  316.    col[3] = 255;
  317.    COLORV( IM, col );
  318.  
  319. /*     COLOR4F( IM, red, green, blue, 1.0 ); */
  320. }
  321.  
  322.  
  323. void GLAPIENTRY glColor3f(CTX_ARG GLfloat red, GLfloat green, GLfloat blue )
  324. {
  325.    GLubyte col[4];
  326.    GET_IMMEDIATE;
  327.    FLOAT_COLOR_TO_UBYTE_COLOR(col[0], red);
  328.    FLOAT_COLOR_TO_UBYTE_COLOR(col[1], green);
  329.    FLOAT_COLOR_TO_UBYTE_COLOR(col[2], blue);
  330.    col[3] = 255;
  331.    COLORV( IM, col );
  332.  
  333. /*     COLOR4F( IM, red, green, blue, 1.0 ); */
  334. }
  335.  
  336.  
  337. void GLAPIENTRY glColor3i(CTX_ARG GLint red, GLint green, GLint blue )
  338. {
  339.    GET_IMMEDIATE;
  340.    COLOR( IM, INT_TO_UBYTE(red), 
  341.       INT_TO_UBYTE(green),
  342.       INT_TO_UBYTE(blue),
  343.       255);
  344. }
  345.  
  346.  
  347. void GLAPIENTRY glColor3s(CTX_ARG GLshort red, GLshort green, GLshort blue )
  348. {
  349.    GET_IMMEDIATE;
  350.    COLOR( IM, SHORT_TO_UBYTE(red), 
  351.       SHORT_TO_UBYTE(green),
  352.       SHORT_TO_UBYTE(blue),
  353.       255);
  354. }
  355.  
  356.  
  357. void GLAPIENTRY glColor3ub(CTX_ARG GLubyte red, GLubyte green, GLubyte blue )
  358. {
  359.    GET_IMMEDIATE;
  360.    COLOR( IM, red, green, blue, 255 );
  361. }
  362.  
  363.  
  364. void GLAPIENTRY glColor3ui(CTX_ARG GLuint red, GLuint green, GLuint blue )
  365. {
  366.    GET_IMMEDIATE;
  367.    COLOR( IM, UINT_TO_UBYTE(red),
  368.       UINT_TO_UBYTE(green),
  369.       UINT_TO_UBYTE(blue),
  370.       255 );
  371. }
  372.  
  373.  
  374. void GLAPIENTRY glColor3us(CTX_ARG GLushort red, GLushort green, GLushort blue )
  375. {
  376.    GET_IMMEDIATE;
  377.    COLOR( IM, USHORT_TO_UBYTE(red), USHORT_TO_UBYTE(green),
  378.       USHORT_TO_UBYTE(blue),
  379.       255 );
  380. }
  381.  
  382.  
  383. void GLAPIENTRY glColor4b(CTX_ARG GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
  384. {
  385.    GET_IMMEDIATE;
  386.    COLOR( IM, BYTE_TO_UBYTE(red), BYTE_TO_UBYTE(green),
  387.       BYTE_TO_UBYTE(blue), BYTE_TO_UBYTE(alpha) );
  388. }
  389.  
  390.  
  391. void GLAPIENTRY glColor4d(CTX_ARG GLdouble red, GLdouble green, GLdouble blue,
  392.                GLdouble alpha )
  393. {
  394.    GLubyte col[4];
  395.    GLfloat r = red;
  396.    GLfloat g = green;
  397.    GLfloat b = blue;
  398.    GLfloat a = alpha;
  399.    GET_IMMEDIATE;
  400.    FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
  401.    FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
  402.    FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
  403.    FLOAT_COLOR_TO_UBYTE_COLOR(col[3], a);
  404.    COLORV( IM, col );
  405.  
  406. /*     COLOR4F( IM, red, green, blue, alpha ); */
  407. }
  408.  
  409.  
  410. void GLAPIENTRY glColor4f(CTX_ARG GLfloat red, GLfloat green,
  411.                            GLfloat blue, GLfloat alpha )
  412. {
  413.    GLubyte col[4];
  414.    GET_IMMEDIATE;
  415.    FLOAT_COLOR_TO_UBYTE_COLOR(col[0], red);
  416.    FLOAT_COLOR_TO_UBYTE_COLOR(col[1], green);
  417.    FLOAT_COLOR_TO_UBYTE_COLOR(col[2], blue);
  418.    FLOAT_COLOR_TO_UBYTE_COLOR(col[3], alpha);
  419.    COLORV( IM, col );
  420.  
  421. /*     COLOR4F( IM, red, green, blue, alpha ); */
  422. }
  423.  
  424. void GLAPIENTRY glColor4i(CTX_ARG GLint red, GLint green, GLint blue, GLint alpha )
  425. {
  426.    GET_IMMEDIATE;
  427.    COLOR( IM, INT_TO_UBYTE(red), INT_TO_UBYTE(green),
  428.       INT_TO_UBYTE(blue), INT_TO_UBYTE(alpha) );
  429. }
  430.  
  431.  
  432. void GLAPIENTRY glColor4s(CTX_ARG GLshort red, GLshort green,
  433.                            GLshort blue, GLshort alpha )
  434. {
  435.    GET_IMMEDIATE;
  436.    COLOR( IM, SHORT_TO_UBYTE(red), SHORT_TO_UBYTE(green),
  437.       SHORT_TO_UBYTE(blue), SHORT_TO_UBYTE(alpha) );
  438. }
  439.  
  440. void GLAPIENTRY glColor4ub(CTX_ARG GLubyte red, GLubyte green,
  441.                             GLubyte blue, GLubyte alpha )
  442. {
  443.    GET_IMMEDIATE;
  444.    COLOR( IM, red, green, blue, alpha );
  445. }
  446.  
  447. void GLAPIENTRY glColor4ui(CTX_ARG GLuint red, GLuint green,
  448.                             GLuint blue, GLuint alpha )
  449. {
  450.    GET_IMMEDIATE;
  451.    COLOR( IM, UINT_TO_UBYTE(red), UINT_TO_UBYTE(green),
  452.       UINT_TO_UBYTE(blue), UINT_TO_UBYTE(alpha) );
  453. }
  454.  
  455. void GLAPIENTRY glColor4us(CTX_ARG GLushort red, GLushort green,
  456.                             GLushort blue, GLushort alpha )
  457. {
  458.    GET_IMMEDIATE;
  459.    COLOR( IM, USHORT_TO_UBYTE(red), USHORT_TO_UBYTE(green),
  460.       USHORT_TO_UBYTE(blue), USHORT_TO_UBYTE(alpha) );
  461. }
  462.  
  463.  
  464. void GLAPIENTRY glColor3bv(CTX_ARG const GLbyte *v )
  465. {
  466.    GET_IMMEDIATE;
  467.    COLOR( IM, BYTE_TO_UBYTE(v[0]), BYTE_TO_UBYTE(v[1]),
  468.       BYTE_TO_UBYTE(v[2]), 255 );
  469. }
  470.  
  471.  
  472. void GLAPIENTRY glColor3dv(CTX_ARG const GLdouble *v )
  473. {
  474.    GLubyte col[4];
  475.    GLfloat r = v[0];
  476.    GLfloat g = v[1];
  477.    GLfloat b = v[2];
  478.    GET_IMMEDIATE;
  479.    FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
  480.    FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
  481.    FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
  482.    col[3]= 255;
  483.    COLORV( IM, col );
  484.  
  485. /*     COLOR4F( IM, v[0], v[1], v[2], v[3] ); */
  486. }
  487.  
  488.  
  489. void GLAPIENTRY glColor3fv(CTX_ARG const GLfloat *v )
  490. {
  491.    GLubyte col[4];
  492.    GET_IMMEDIATE;
  493.    FLOAT_COLOR_TO_UBYTE_COLOR(col[0], v[0]);
  494.    FLOAT_COLOR_TO_UBYTE_COLOR(col[1], v[1]);
  495.    FLOAT_COLOR_TO_UBYTE_COLOR(col[2], v[2]);
  496.    col[3] = 255;
  497.    COLORV( IM, col );
  498.  
  499. /*     COLOR4F( IM, v[0], v[1], v[2], v[3] ); */
  500. }
  501.  
  502.  
  503. void GLAPIENTRY glColor3iv(CTX_ARG const GLint *v )
  504. {
  505.    GET_IMMEDIATE;
  506.    COLOR( IM, INT_TO_UBYTE(v[0]), INT_TO_UBYTE(v[1]),
  507.       INT_TO_UBYTE(v[2]), 255 );
  508. }
  509.  
  510.  
  511. void GLAPIENTRY glColor3sv(CTX_ARG const GLshort *v )
  512. {
  513.    GET_IMMEDIATE;
  514.    COLOR( IM, SHORT_TO_UBYTE(v[0]), SHORT_TO_UBYTE(v[1]),
  515.       SHORT_TO_UBYTE(v[2]), 255 );
  516. }
  517.  
  518.  
  519. void GLAPIENTRY glColor3ubv(CTX_ARG const GLubyte *v )
  520. {
  521.    GET_IMMEDIATE;
  522.    COLOR( IM, v[0], v[1], v[2], 255 );
  523. }
  524.  
  525.  
  526. void GLAPIENTRY glColor3uiv(CTX_ARG const GLuint *v )
  527. {
  528.    GET_IMMEDIATE;
  529.    COLOR( IM, UINT_TO_UBYTE(v[0]), UINT_TO_UBYTE(v[1]),
  530.       UINT_TO_UBYTE(v[2]), 255 );
  531. }
  532.  
  533.  
  534. void GLAPIENTRY glColor3usv(CTX_ARG const GLushort *v )
  535. {
  536.    GET_IMMEDIATE;
  537.    COLOR( IM, USHORT_TO_UBYTE(v[0]), USHORT_TO_UBYTE(v[1]),
  538.       USHORT_TO_UBYTE(v[2]), 255 );
  539.  
  540. }
  541.  
  542.  
  543. void GLAPIENTRY glColor4bv(CTX_ARG const GLbyte *v )
  544. {
  545.    GET_IMMEDIATE;
  546.    COLOR( IM, BYTE_TO_UBYTE(v[0]), BYTE_TO_UBYTE(v[1]),
  547.       BYTE_TO_UBYTE(v[2]), BYTE_TO_UBYTE(v[3]) );
  548. }
  549.  
  550.  
  551. void GLAPIENTRY glColor4dv(CTX_ARG const GLdouble *v )
  552. {
  553.    GLubyte col[4];
  554.    GLfloat r = v[0];
  555.    GLfloat g = v[1];
  556.    GLfloat b = v[2];
  557.    GLfloat a = v[3];
  558.    GET_IMMEDIATE;
  559.    FLOAT_COLOR_TO_UBYTE_COLOR(col[0], r);
  560.    FLOAT_COLOR_TO_UBYTE_COLOR(col[1], g);
  561.    FLOAT_COLOR_TO_UBYTE_COLOR(col[2], b);
  562.    FLOAT_COLOR_TO_UBYTE_COLOR(col[3], a);
  563.    COLORV( IM, col );
  564.  
  565. /*     COLOR4F( IM, v[0], v[1], v[2], v[3] ); */
  566. }
  567.  
  568.  
  569. void GLAPIENTRY glColor4fv(CTX_ARG const GLfloat *v )
  570. {
  571.    GLubyte col[4];
  572.    GET_IMMEDIATE;
  573.    FLOAT_COLOR_TO_UBYTE_COLOR(col[0], v[0]);
  574.    FLOAT_COLOR_TO_UBYTE_COLOR(col[1], v[1]);
  575.    FLOAT_COLOR_TO_UBYTE_COLOR(col[2], v[2]);
  576.    FLOAT_COLOR_TO_UBYTE_COLOR(col[3], v[3]);
  577.    COLORV( IM, col );
  578.  
  579. /*     COLOR4F( IM, v[0], v[1], v[2], v[3] ); */
  580. }
  581.  
  582.  
  583. void GLAPIENTRY glColor4iv(CTX_ARG const GLint *v )
  584. {
  585.    GET_IMMEDIATE;
  586.    COLOR( IM, INT_TO_UBYTE(v[0]), INT_TO_UBYTE(v[1]),
  587.       INT_TO_UBYTE(v[2]), INT_TO_UBYTE(v[3]) );
  588. }
  589.  
  590.  
  591. void GLAPIENTRY glColor4sv(CTX_ARG const GLshort *v )
  592. {
  593.    GET_IMMEDIATE;
  594.    COLOR( IM, SHORT_TO_UBYTE(v[0]), SHORT_TO_UBYTE(v[1]),
  595.       SHORT_TO_UBYTE(v[2]), SHORT_TO_UBYTE(v[3]) );
  596. }
  597.  
  598.  
  599. void GLAPIENTRY glColor4ubv(CTX_ARG const GLubyte *v )
  600. {
  601.    GET_IMMEDIATE;
  602.    COLORV( IM, v );
  603. }
  604.  
  605.  
  606. void GLAPIENTRY glColor4uiv(CTX_ARG const GLuint *v )
  607. {
  608.    GET_IMMEDIATE;
  609.    COLOR( IM, UINT_TO_UBYTE(v[0]), UINT_TO_UBYTE(v[1]),
  610.       UINT_TO_UBYTE(v[2]), UINT_TO_UBYTE(v[3]) );
  611. }
  612.  
  613.  
  614. void GLAPIENTRY glColor4usv(CTX_ARG const GLushort *v )
  615. {
  616.    GET_IMMEDIATE;
  617.    COLOR( IM, USHORT_TO_UBYTE(v[0]), USHORT_TO_UBYTE(v[1]),
  618.       USHORT_TO_UBYTE(v[2]), USHORT_TO_UBYTE(v[3]) );
  619. }
  620.  
  621.  
  622. void GLAPIENTRY glColorMask(CTX_ARG GLboolean red, GLboolean green,
  623.                              GLboolean blue, GLboolean alpha )
  624. {
  625.    GET_CONTEXT;
  626.    CHECK_CONTEXT;
  627.    (*CC->API.ColorMask)(CC, red, green, blue, alpha);
  628. }
  629.  
  630.  
  631. void GLAPIENTRY glColorMaterial(CTX_ARG GLenum face, GLenum mode )
  632. {
  633.    GET_CONTEXT;
  634.    CHECK_CONTEXT;
  635.    (*CC->API.ColorMaterial)(CC, face, mode);
  636. }
  637.  
  638.  
  639. void GLAPIENTRY glCopyPixels(CTX_ARG GLint x, GLint y, GLsizei width, GLsizei height,
  640.                               GLenum type )
  641. {
  642.    GET_CONTEXT;
  643.    CHECK_CONTEXT;
  644.    (*CC->API.CopyPixels)(CC, x, y, width, height, type);
  645. }
  646.  
  647.  
  648. void GLAPIENTRY glCopyTexImage1D(CTX_ARG GLenum target, GLint level,
  649.                                   GLenum internalformat,
  650.                                   GLint x, GLint y,
  651.                                   GLsizei width, GLint border )
  652. {
  653.    GET_CONTEXT;
  654.    CHECK_CONTEXT;
  655.    (*CC->API.CopyTexImage1D)( CC, target, level, internalformat,
  656.                               x, y, width, border );
  657. }
  658.  
  659.  
  660. void GLAPIENTRY glCopyTexImage2D(CTX_ARG GLenum target, GLint level,
  661.                                   GLenum internalformat,
  662.                                   GLint x, GLint y,
  663.                                   GLsizei width, GLsizei height, GLint border )
  664. {
  665.    GET_CONTEXT;
  666.    CHECK_CONTEXT;
  667.    (*CC->API.CopyTexImage2D)( CC, target, level, internalformat,
  668.                               x, y, width, height, border );
  669. }
  670.  
  671.  
  672. void GLAPIENTRY glCopyTexSubImage1D(CTX_ARG GLenum target, GLint level,
  673.                                      GLint xoffset, GLint x, GLint y,
  674.                                      GLsizei width )
  675. {
  676.    GET_CONTEXT;
  677.    CHECK_CONTEXT;
  678.    (*CC->API.CopyTexSubImage1D)( CC, target, level, xoffset, x, y, width );
  679. }
  680.  
  681.  
  682. void GLAPIENTRY glCopyTexSubImage2D(CTX_ARG GLenum target, GLint level,
  683.                                      GLint xoffset, GLint yoffset,
  684.                                      GLint x, GLint y,
  685.                                      GLsizei width, GLsizei height )
  686. {
  687.    GET_CONTEXT;
  688.    CHECK_CONTEXT;
  689.    (*CC->API.CopyTexSubImage2D)( CC, target, level, xoffset, yoffset,
  690.                                  x, y, width, height );
  691. }
  692.  
  693.  
  694. /* 1.2 */
  695. void GLAPIENTRY glCopyTexSubImage3D(CTX_ARG GLenum target, GLint level, GLint xoffset,
  696.                                      GLint yoffset, GLint zoffset,
  697.                                      GLint x, GLint y, GLsizei width,
  698.                                      GLsizei height )
  699. {
  700.    GET_CONTEXT;
  701.    CHECK_CONTEXT;
  702.    (*CC->API.CopyTexSubImage3D)( CC, target, level, xoffset, yoffset,
  703.                                  zoffset, x, y, width, height );
  704. }
  705.  
  706.  
  707.  
  708. void GLAPIENTRY glCullFace(CTX_ARG GLenum mode )
  709. {
  710.    GET_CONTEXT;
  711.    CHECK_CONTEXT;
  712.    (*CC->API.CullFace)(CC, mode);
  713. }
  714.  
  715.  
  716. void GLAPIENTRY glDepthFunc(CTX_ARG GLenum func )
  717. {
  718.    GET_CONTEXT;
  719.    CHECK_CONTEXT;
  720.    (*CC->API.DepthFunc)( CC, func );
  721. }
  722.  
  723.  
  724. void GLAPIENTRY glDepthMask(CTX_ARG GLboolean flag )
  725. {
  726.    GET_CONTEXT;
  727.    CHECK_CONTEXT;
  728.    (*CC->API.DepthMask)( CC, flag );
  729. }
  730.  
  731.  
  732. void GLAPIENTRY glDepthRange(CTX_ARG GLclampd near_val, GLclampd far_val )
  733. {
  734.    GET_CONTEXT;
  735.    CHECK_CONTEXT;
  736.    (*CC->API.DepthRange)( CC, near_val, far_val );
  737. }
  738.  
  739.  
  740. void GLAPIENTRY glDeleteLists(CTX_ARG GLuint list, GLsizei range )
  741. {
  742.    GET_CONTEXT;
  743.    CHECK_CONTEXT;
  744.    (*CC->API.DeleteLists)(CC, list, range);
  745. }
  746.  
  747.  
  748. void GLAPIENTRY glDeleteTextures(CTX_ARG GLsizei n, const GLuint *textures )
  749. {
  750.    GET_CONTEXT;
  751.    CHECK_CONTEXT;
  752.    (*CC->API.DeleteTextures)(CC, n, textures);
  753. }
  754.  
  755.  
  756. void GLAPIENTRY glDisable(CTX_ARG GLenum cap )
  757. {
  758.    GET_CONTEXT;
  759.    CHECK_CONTEXT;
  760.    (*CC->API.Disable)( CC, cap );
  761. }
  762.  
  763.  
  764. void GLAPIENTRY glDisableClientState(CTX_ARG GLenum cap )
  765. {
  766.    GET_CONTEXT;
  767.    CHECK_CONTEXT;
  768.    (*CC->API.DisableClientState)( CC, cap );
  769. }
  770.  
  771.  
  772. void GLAPIENTRY glDrawArrays(CTX_ARG GLenum mode, GLint first, GLsizei count )
  773. {
  774.    GET_CONTEXT;
  775.    CHECK_CONTEXT;
  776.    gl_DrawArrays(CC, mode, first, count);
  777. }
  778.  
  779.  
  780. void GLAPIENTRY glDrawBuffer(CTX_ARG GLenum mode )
  781. {
  782.    GET_CONTEXT;
  783.    CHECK_CONTEXT;
  784.    (*CC->API.DrawBuffer)(CC, mode);
  785. }
  786.  
  787.  
  788.  
  789. void GLAPIENTRY glDrawPixels(CTX_ARG GLsizei width, GLsizei height, GLenum format,
  790.                               GLenum type, const GLvoid *pixels )
  791. {
  792.    GET_CONTEXT;
  793.    CHECK_CONTEXT;
  794.    if (CC->CompileFlag || !gl_direct_DrawPixels(CC, &CC->Unpack, width, height,
  795.                                                 format, type, pixels)) {
  796.       struct gl_image *image;
  797.       image = gl_unpack_image( CC, width, height, format, type, pixels, &CC->Unpack );
  798.       (*CC->API.DrawPixels)( CC, image );
  799.       if (image->RefCount==0) {
  800.          /* image not in display list */
  801.          gl_free_image( image );
  802.       }
  803.    }
  804. }
  805.  
  806.  
  807. void GLAPIENTRY glEnable(CTX_ARG GLenum cap )
  808. {
  809.    GET_CONTEXT;
  810.    CHECK_CONTEXT;
  811.    (*CC->API.Enable)( CC, cap );
  812. }
  813.  
  814.  
  815. void GLAPIENTRY glEnableClientState(CTX_ARG GLenum cap )
  816. {
  817.    GET_CONTEXT;
  818.    CHECK_CONTEXT;
  819.    (*CC->API.EnableClientState)( CC, cap );
  820. }
  821.  
  822.  
  823. /* KW: Both streams now go to the outside-begin-end state.  Raise
  824.  *     errors for either stream if it was not in the inside state.
  825.  */
  826. void GLAPIENTRY glEnd(CTX_VOID )
  827. {
  828.    GLuint state;
  829.    GLuint inflags;
  830.    GET_IMMEDIATE;
  831.  
  832.  
  833.    state = IM->BeginState;
  834.    inflags = (~state) & (VERT_BEGIN_0|VERT_BEGIN_1);
  835.    state |= inflags << 2;    /* errors */
  836.  
  837.    if (MESA_VERBOSE&VERBOSE_API) {
  838.       if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
  839.      fprintf(stderr, "glEnd(IM %d), BeginState is %x, errors %x\n", 
  840.          IM->id, state,
  841.          inflags<<2);
  842.       else
  843.      fprintf(stderr, ">");
  844.    }
  845.  
  846.    
  847.    if (inflags != (VERT_BEGIN_0|VERT_BEGIN_1))
  848.    {
  849.       GLuint count = IM->Count;
  850.       GLuint last = IM->LastPrimitive;
  851.  
  852.       state &= ~(VERT_BEGIN_0|VERT_BEGIN_1); /* update state */
  853.       IM->Flag[count] |= VERT_END;
  854.       IM->NextPrimitive[IM->LastPrimitive] = count;
  855.       IM->LastPrimitive = count;
  856.       IM->Primitive[count] = GL_POLYGON+1;
  857.  
  858.       if (IM->FlushElt) {
  859.      gl_exec_array_elements( IM->backref, IM, last, count );
  860.      IM->FlushElt = 0;
  861.       }
  862.    }
  863.    
  864.    if (MESA_VERBOSE&VERBOSE_API)
  865.       fprintf(stderr, "in glEnd final state %x\n", state);
  866.  
  867.    IM->BeginState = state;      
  868.  
  869.    if ((MESA_DEBUG_FLAGS&DEBUG_ALWAYS_FLUSH))
  870.       IM->maybe_transform_vb( IM );
  871. }
  872.  
  873.  
  874. void gl_End( GLcontext *ctx )
  875. {
  876.    struct immediate *IM = ctx->input;
  877.    GLuint state = IM->BeginState;
  878.    GLuint inflags = (~state) & (VERT_BEGIN_0|VERT_BEGIN_1);
  879.  
  880.  
  881.    if (MESA_VERBOSE&VERBOSE_API) {
  882.       if (MESA_VERBOSE&VERBOSE_IMMEDIATE)
  883.      fprintf(stderr, "gl_End(IM %d), BeginState is %x, errors %x\n", 
  884.          IM->id, state,
  885.          inflags<<2);
  886.       else
  887.      fprintf(stderr, ">");
  888.    }
  889.  
  890.    state |= inflags << 2;    /* errors */
  891.  
  892.    if (inflags != (VERT_BEGIN_0|VERT_BEGIN_1))
  893.    {
  894.       GLuint count = IM->Count;
  895.       GLuint last = IM->LastPrimitive;
  896.  
  897.       state &= ~(VERT_BEGIN_0|VERT_BEGIN_1); /* update state */
  898.       IM->Flag[count] |= VERT_END;
  899.       IM->NextPrimitive[IM->LastPrimitive] = count;
  900.       IM->LastPrimitive = count;
  901.       IM->Primitive[count] = GL_POLYGON+1;
  902.  
  903.       if (IM->FlushElt) {
  904.      gl_exec_array_elements( ctx, IM, last, count );
  905.      IM->FlushElt = 0;
  906.       }
  907.    }
  908.  
  909.    IM->BeginState = state;      
  910.  
  911.    /* You can set this flag to get the old 'flush vb on glEnd()'
  912.     * behaviour.
  913.     */
  914.    if ((MESA_DEBUG_FLAGS&DEBUG_ALWAYS_FLUSH))
  915.       IM->maybe_transform_vb( IM );
  916. }
  917.  
  918. void GLAPIENTRY glEndList(CTX_VOID )
  919. {
  920.    GET_CONTEXT;
  921.    CHECK_CONTEXT;
  922.    (*CC->API.EndList)(CC);
  923. }
  924.  
  925. /* KW: If are compiling, we don't know whether eval will produce a
  926.  *     vertex when it is run in the future.  If this is pure immediate
  927.  *     mode, eval is a noop if neither vertex map is enabled.
  928.  *
  929.  *     Thus we need to have a check in the display list code or
  930.  *     elsewhere for eval(1,2) vertices in the case where
  931.  *     map(1,2)_vertex is disabled, and to purge those vertices from
  932.  *     the vb.  This is currently done
  933.  *     via  modifications to the cull_vb and render_vb operations, and
  934.  *     by using the existing cullmask mechanism for all other operations.  
  935.  */
  936.  
  937.  
  938. /* KW: Because the eval values don't become 'current', fixup will flow
  939.  *     through these vertices, and then evaluation will write on top
  940.  *     of the fixup results.  
  941.  *
  942.  *     This is a little inefficient, but at least it is correct.  This
  943.  *     could be short-circuited in the case where all vertices are
  944.  *     eval-vertices, or more generally by a cullmask in fixup.
  945.  *
  946.  *     Note: using Obj to hold eval coord data.  This data is actually
  947.  *     transformed if eval is disabled.  But disabling eval & sending
  948.  *     eval coords is stupid, right?
  949.  */
  950.  
  951.  
  952. #define EVALCOORD1(IM, x)                \
  953. {                            \
  954.    GLuint count = IM->Count++;                \
  955.    IM->Flag[count] |= VERT_EVAL_C1;            \
  956.    ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);        \
  957.    if (count == VB_MAX-1)                \
  958.       IM->maybe_transform_vb( IM );            \
  959. }
  960.  
  961. #define EVALCOORD2(IM, x, y)                \
  962. {                            \
  963.    GLuint count = IM->Count++;                \
  964.    IM->Flag[count] |= VERT_EVAL_C2;            \
  965.    ASSIGN_4V(IM->Obj[count], x, y, 0, 1);        \
  966.    if (count == VB_MAX-1)                \
  967.       IM->maybe_transform_vb( IM );            \
  968. }
  969.  
  970. #define EVALPOINT1(IM, x)                \
  971. {                            \
  972.    GLuint count = IM->Count++;                \
  973.    IM->Flag[count] |= VERT_EVAL_P1;            \
  974.    ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);        \
  975.    if (count == VB_MAX-1)                \
  976.       IM->maybe_transform_vb( IM );            \
  977. }
  978.  
  979. #define EVALPOINT2(IM, x, y)                \
  980. {                            \
  981.    GLuint count = IM->Count++;                \
  982.    IM->Flag[count] |= VERT_EVAL_P2;            \
  983.    ASSIGN_4V(IM->Obj[count], x, y, 0, 1);        \
  984.    if (count == VB_MAX-1)                \
  985.       IM->maybe_transform_vb( IM );            \
  986. }
  987.  
  988.  
  989. void GLAPIENTRY glEvalCoord1d(CTX_ARG GLdouble u )
  990. {
  991.    GET_IMMEDIATE;
  992.    EVALCOORD1( IM, (GLfloat) u );
  993. }
  994.  
  995.  
  996. void GLAPIENTRY glEvalCoord1f(CTX_ARG GLfloat u )
  997. {
  998.    GET_IMMEDIATE;
  999.    EVALCOORD1( IM, u );
  1000. }
  1001.  
  1002.  
  1003. /* Lame internal function:
  1004.  */
  1005. void gl_EvalCoord1f( GLcontext *CC, GLfloat u )
  1006. {
  1007.    struct immediate *i = CC->input;
  1008.    EVALCOORD1( i, u );
  1009. }
  1010.  
  1011.  
  1012. void GLAPIENTRY glEvalCoord1dv(CTX_ARG const GLdouble *u )
  1013. {
  1014.    GET_IMMEDIATE;
  1015.    EVALCOORD1( IM, (GLfloat) *u );
  1016. }
  1017.  
  1018.  
  1019. void GLAPIENTRY glEvalCoord1fv(CTX_ARG const GLfloat *u )
  1020. {
  1021.    GET_IMMEDIATE;
  1022.    EVALCOORD1( IM, (GLfloat) *u );
  1023. }
  1024.  
  1025.  
  1026. void GLAPIENTRY glEvalCoord2d(CTX_ARG GLdouble u, GLdouble v )
  1027. {
  1028.    GET_IMMEDIATE;
  1029.    EVALCOORD2( IM, (GLfloat) u, (GLfloat) v );
  1030. }
  1031.  
  1032.  
  1033. void GLAPIENTRY glEvalCoord2f(CTX_ARG GLfloat u, GLfloat v )
  1034. {
  1035.    GET_IMMEDIATE;
  1036.    EVALCOORD2( IM, u, v );
  1037. }
  1038.  
  1039.  
  1040. /* Lame internal function:
  1041.  */
  1042. void gl_EvalCoord2f( GLcontext *CC, GLfloat u, GLfloat v )
  1043. {
  1044.    struct immediate *i = CC->input;
  1045.    EVALCOORD2( i, u, v );
  1046. }
  1047.  
  1048.  
  1049. void GLAPIENTRY glEvalCoord2dv(CTX_ARG const GLdouble *u )
  1050. {
  1051.    GET_IMMEDIATE;
  1052.    EVALCOORD2( IM, (GLfloat) u[0], (GLfloat) u[1] );
  1053. }
  1054.  
  1055.  
  1056. void GLAPIENTRY glEvalCoord2fv(CTX_ARG const GLfloat *u )
  1057. {
  1058.    GET_IMMEDIATE;
  1059.    EVALCOORD2( IM, u[0], u[1] );
  1060. }
  1061.  
  1062.  
  1063. void GLAPIENTRY glEvalPoint1(CTX_ARG GLint i )
  1064. {
  1065.    GET_IMMEDIATE;
  1066.    EVALPOINT1( IM, i );
  1067. }
  1068.  
  1069.  
  1070. void GLAPIENTRY glEvalPoint2(CTX_ARG GLint i, GLint j )
  1071. {
  1072.    GET_IMMEDIATE;
  1073.    EVALPOINT2( IM, i, j );
  1074. }
  1075.  
  1076.  
  1077. void GLAPIENTRY glEvalMesh1(CTX_ARG GLenum mode, GLint i1, GLint i2 )
  1078. {
  1079.    GET_CONTEXT;
  1080.    CHECK_CONTEXT;
  1081.    (*CC->API.EvalMesh1)( CC, mode, i1, i2 );
  1082. }
  1083.  
  1084.  
  1085. void GLAPIENTRY glEdgeFlag(CTX_ARG GLboolean flag )
  1086. {
  1087.    GLuint count;
  1088.    GET_IMMEDIATE;
  1089.    count = IM->Count;
  1090.    IM->EdgeFlag[count] = flag;
  1091.    IM->Flag[count] |= VERT_EDGE;
  1092. }
  1093.  
  1094.  
  1095. void GLAPIENTRY glEdgeFlagv(CTX_ARG const GLboolean *flag )
  1096. {
  1097.    GLuint count;
  1098.    GET_IMMEDIATE;
  1099.    count = IM->Count;
  1100.    IM->EdgeFlag[count] = *flag;
  1101.    IM->Flag[count] |= VERT_EDGE;
  1102. }
  1103.  
  1104.  
  1105.  
  1106. void GLAPIENTRY glEvalMesh2(CTX_ARG GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
  1107. {
  1108.    GET_CONTEXT;
  1109.    CHECK_CONTEXT;
  1110.    (*CC->API.EvalMesh2)( CC, mode, i1, i2, j1, j2 );
  1111. }
  1112.  
  1113.  
  1114. void GLAPIENTRY glFeedbackBuffer(CTX_ARG GLsizei size, GLenum type, GLfloat *buffer )
  1115. {
  1116.    GET_CONTEXT;
  1117.    CHECK_CONTEXT;
  1118.    (*CC->API.FeedbackBuffer)(CC, size, type, buffer);
  1119. }
  1120.  
  1121.  
  1122. void GLAPIENTRY glFinish(CTX_VOID )
  1123. {
  1124.    GET_CONTEXT;
  1125.    CHECK_CONTEXT;
  1126.    (*CC->API.Finish)(CC);
  1127. }
  1128.  
  1129.  
  1130. void GLAPIENTRY glFlush(CTX_VOID )
  1131. {
  1132.    GET_CONTEXT;
  1133.    CHECK_CONTEXT;
  1134.    (*CC->API.Flush)(CC);
  1135. }
  1136.  
  1137.  
  1138. void GLAPIENTRY glFogf(CTX_ARG GLenum pname, GLfloat param )
  1139. {
  1140.    GET_CONTEXT;
  1141.    CHECK_CONTEXT;
  1142.    (*CC->API.Fogfv)(CC, pname, ¶m);
  1143. }
  1144.  
  1145.  
  1146. void GLAPIENTRY glFogi(CTX_ARG GLenum pname, GLint param )
  1147. {
  1148.    GLfloat fparam = (GLfloat) param;
  1149.    GET_CONTEXT;
  1150.    CHECK_CONTEXT;
  1151.    (*CC->API.Fogfv)(CC, pname, &fparam);
  1152. }
  1153.  
  1154.  
  1155. void GLAPIENTRY glFogfv(CTX_ARG GLenum pname, const GLfloat *params )
  1156. {
  1157.    GET_CONTEXT;
  1158.    CHECK_CONTEXT;
  1159.    (*CC->API.Fogfv)(CC, pname, params);
  1160. }
  1161.  
  1162.  
  1163. void GLAPIENTRY glFogiv(CTX_ARG GLenum pname, const GLint *params )
  1164. {
  1165.    GLfloat p[4];
  1166.    GET_CONTEXT;
  1167.    CHECK_CONTEXT;
  1168.  
  1169.    switch (pname) {
  1170.       case GL_FOG_MODE:
  1171.       case GL_FOG_DENSITY:
  1172.       case GL_FOG_START:
  1173.       case GL_FOG_END:
  1174.       case GL_FOG_INDEX:
  1175.      p[0] = (GLfloat) *params;
  1176.      break;
  1177.       case GL_FOG_COLOR:
  1178.      p[0] = INT_TO_FLOAT( params[0] );
  1179.      p[1] = INT_TO_FLOAT( params[1] );
  1180.      p[2] = INT_TO_FLOAT( params[2] );
  1181.      p[3] = INT_TO_FLOAT( params[3] );
  1182.      break;
  1183.       default:
  1184.          /* Error will be caught later in gl_Fogfv */
  1185.          ;
  1186.    }
  1187.    (*CC->API.Fogfv)( CC, pname, p );
  1188. }
  1189.  
  1190.  
  1191. void GLAPIENTRY glFrontFace(CTX_ARG GLenum mode )
  1192. {
  1193.    GET_CONTEXT;
  1194.    CHECK_CONTEXT;
  1195.    (*CC->API.FrontFace)(CC, mode);
  1196. }
  1197.  
  1198.  
  1199. void GLAPIENTRY glFrustum(CTX_ARG GLdouble left, GLdouble right,
  1200.                          GLdouble bottom, GLdouble top,
  1201.                          GLdouble nearval, GLdouble farval )
  1202. {
  1203.    GET_CONTEXT;
  1204.    CHECK_CONTEXT;
  1205.    (*CC->API.Frustum)(CC, left, right, bottom, top, nearval, farval);
  1206. }
  1207.  
  1208.  
  1209. GLuint GLAPIENTRY glGenLists(CTX_ARG GLsizei range )
  1210. {
  1211.    GET_CONTEXT;
  1212.    CHECK_CONTEXT_RETURN(0);
  1213.    return (*CC->API.GenLists)(CC, range);
  1214. }
  1215.  
  1216.  
  1217. void GLAPIENTRY glGenTextures(CTX_ARG GLsizei n, GLuint *textures )
  1218. {
  1219.    GET_CONTEXT;
  1220.    CHECK_CONTEXT;
  1221.    (*CC->API.GenTextures)(CC, n, textures);
  1222. }
  1223.  
  1224.  
  1225. void GLAPIENTRY glGetBooleanv(CTX_ARG GLenum pname, GLboolean *params )
  1226. {
  1227.    GET_CONTEXT;
  1228.    CHECK_CONTEXT;
  1229.    (*CC->API.GetBooleanv)(CC, pname, params);
  1230. }
  1231.  
  1232.  
  1233. void GLAPIENTRY glGetClipPlane(CTX_ARG GLenum plane, GLdouble *equation )
  1234. {
  1235.    GET_CONTEXT;
  1236.    CHECK_CONTEXT;
  1237.    (*CC->API.GetClipPlane)(CC, plane, equation);
  1238. }
  1239.  
  1240.  
  1241. void GLAPIENTRY glGetDoublev(CTX_ARG GLenum pname, GLdouble *params )
  1242. {
  1243.    GET_CONTEXT;
  1244.    CHECK_CONTEXT;
  1245.    (*CC->API.GetDoublev)(CC, pname, params);
  1246. }
  1247.  
  1248.  
  1249. GLenum GLAPIENTRY glGetError(CTX_VOID )
  1250. {
  1251.    GET_CONTEXT;
  1252.    if (!CC) {
  1253.       /* No current context */
  1254.       return (GLenum) GL_NO_ERROR;
  1255.    }
  1256.    return (*CC->API.GetError)(CC);
  1257. }
  1258.  
  1259.  
  1260. void GLAPIENTRY glGetFloatv(CTX_ARG GLenum pname, GLfloat *params )
  1261. {
  1262.    GET_CONTEXT;
  1263.    CHECK_CONTEXT;
  1264.    (*CC->API.GetFloatv)(CC, pname, params);
  1265. }
  1266.  
  1267.  
  1268. void GLAPIENTRY glGetIntegerv(CTX_ARG GLenum pname, GLint *params )
  1269. {
  1270.    GET_CONTEXT;
  1271.    CHECK_CONTEXT;
  1272.    (*CC->API.GetIntegerv)(CC, pname, params);
  1273. }
  1274.  
  1275.  
  1276. void GLAPIENTRY glGetLightfv(CTX_ARG GLenum light, GLenum pname, GLfloat *params )
  1277. {
  1278.    GET_CONTEXT;
  1279.    CHECK_CONTEXT;
  1280.    (*CC->API.GetLightfv)(CC, light, pname, params);
  1281. }
  1282.  
  1283.  
  1284. void GLAPIENTRY glGetLightiv(CTX_ARG GLenum light, GLenum pname, GLint *params )
  1285. {
  1286.    GET_CONTEXT;
  1287.    CHECK_CONTEXT;
  1288.    (*CC->API.GetLightiv)(CC, light, pname, params);
  1289. }
  1290.  
  1291.  
  1292. void GLAPIENTRY glGetMapdv(CTX_ARG GLenum target, GLenum query, GLdouble *v )
  1293. {
  1294.    GET_CONTEXT;
  1295.    CHECK_CONTEXT;
  1296.    (*CC->API.GetMapdv)( CC, target, query, v );
  1297. }
  1298.  
  1299.  
  1300. void GLAPIENTRY glGetMapfv(CTX_ARG GLenum target, GLenum query, GLfloat *v )
  1301. {
  1302.    GET_CONTEXT;
  1303.    CHECK_CONTEXT;
  1304.    (*CC->API.GetMapfv)( CC, target, query, v );
  1305. }
  1306.  
  1307.  
  1308. void GLAPIENTRY glGetMapiv(CTX_ARG GLenum target, GLenum query, GLint *v )
  1309. {
  1310.    GET_CONTEXT;
  1311.    CHECK_CONTEXT;
  1312.    (*CC->API.GetMapiv)( CC, target, query, v );
  1313. }
  1314.  
  1315.  
  1316. void GLAPIENTRY glGetMaterialfv(CTX_ARG GLenum face, GLenum pname, GLfloat *params )
  1317. {
  1318.    GET_CONTEXT;
  1319.    CHECK_CONTEXT;
  1320.    (*CC->API.GetMaterialfv)(CC, face, pname, params);
  1321. }
  1322.  
  1323.  
  1324. void GLAPIENTRY glGetMaterialiv(CTX_ARG GLenum face, GLenum pname, GLint *params )
  1325. {
  1326.    GET_CONTEXT;
  1327.    CHECK_CONTEXT;
  1328.    (*CC->API.GetMaterialiv)(CC, face, pname, params);
  1329. }
  1330.  
  1331.  
  1332. void GLAPIENTRY glGetPixelMapfv(CTX_ARG GLenum map, GLfloat *values )
  1333. {
  1334.    GET_CONTEXT;
  1335.    CHECK_CONTEXT;
  1336.    (*CC->API.GetPixelMapfv)(CC, map, values);
  1337. }
  1338.  
  1339.  
  1340. void GLAPIENTRY glGetPixelMapuiv(CTX_ARG GLenum map, GLuint *values )
  1341. {
  1342.    GET_CONTEXT;
  1343.    CHECK_CONTEXT;
  1344.    (*CC->API.GetPixelMapuiv)(CC, map, values);
  1345. }
  1346.  
  1347.  
  1348. void GLAPIENTRY glGetPixelMapusv(CTX_ARG GLenum map, GLushort *values )
  1349. {
  1350.    GET_CONTEXT;
  1351.    CHECK_CONTEXT;
  1352.    (*CC->API.GetPixelMapusv)(CC, map, values);
  1353. }
  1354.  
  1355.  
  1356. void GLAPIENTRY glGetPointerv(CTX_ARG GLenum pname, GLvoid **params )
  1357. {
  1358.    GET_CONTEXT;
  1359.    CHECK_CONTEXT;
  1360.    (*CC->API.GetPointerv)(CC, pname, params);
  1361. }
  1362.  
  1363.  
  1364. void GLAPIENTRY glGetPolygonStipple(CTX_ARG GLubyte *mask )
  1365. {
  1366.    GET_CONTEXT;
  1367.    CHECK_CONTEXT;
  1368.    (*CC->API.GetPolygonStipple)(CC, mask);
  1369. }
  1370.  
  1371.  
  1372. const GLubyte * GLAPIENTRY glGetString(CTX_ARG GLenum name )
  1373. {
  1374.    GET_CONTEXT;
  1375.    CHECK_CONTEXT_RETURN(NULL);
  1376.    /* even check for NULL context when not compiled with -DDEBUG */
  1377.    if (!CC)
  1378.       return NULL;
  1379.    return (*CC->API.GetString)(CC, name);
  1380. }
  1381.  
  1382.  
  1383. void GLAPIENTRY glGetTexEnvfv(CTX_ARG GLenum target, GLenum pname, GLfloat *params )
  1384. {
  1385.    GET_CONTEXT;
  1386.    CHECK_CONTEXT;
  1387.    (*CC->API.GetTexEnvfv)(CC, target, pname, params);
  1388. }
  1389.  
  1390.  
  1391. void GLAPIENTRY glGetTexEnviv(CTX_ARG GLenum target, GLenum pname, GLint *params )
  1392. {
  1393.    GET_CONTEXT;
  1394.    CHECK_CONTEXT;
  1395.    (*CC->API.GetTexEnviv)(CC, target, pname, params);
  1396. }
  1397.  
  1398.  
  1399. void GLAPIENTRY glGetTexGeniv(CTX_ARG GLenum coord, GLenum pname, GLint *params )
  1400. {
  1401.    GET_CONTEXT;
  1402.    CHECK_CONTEXT;
  1403.    (*CC->API.GetTexGeniv)(CC, coord, pname, params);
  1404. }
  1405.  
  1406.  
  1407. void GLAPIENTRY glGetTexGendv(CTX_ARG GLenum coord, GLenum pname, GLdouble *params )
  1408. {
  1409.    GET_CONTEXT;
  1410.    CHECK_CONTEXT;
  1411.    (*CC->API.GetTexGendv)(CC, coord, pname, params);
  1412. }
  1413.  
  1414.  
  1415. void GLAPIENTRY glGetTexGenfv(CTX_ARG GLenum coord, GLenum pname, GLfloat *params )
  1416. {
  1417.    GET_CONTEXT;
  1418.    CHECK_CONTEXT;
  1419.    (*CC->API.GetTexGenfv)(CC, coord, pname, params);
  1420. }
  1421.  
  1422.  
  1423. void GLAPIENTRY glGetTexImage(CTX_ARG GLenum target, GLint level, GLenum format,
  1424.                                GLenum type, GLvoid *pixels )
  1425. {
  1426.    GET_CONTEXT;
  1427.    CHECK_CONTEXT;
  1428.    (*CC->API.GetTexImage)(CC, target, level, format, type, pixels);
  1429. }
  1430.  
  1431.  
  1432. void GLAPIENTRY glGetTexLevelParameterfv(CTX_ARG GLenum target, GLint level,
  1433.                                           GLenum pname, GLfloat *params )
  1434. {
  1435.    GET_CONTEXT;
  1436.    CHECK_CONTEXT;
  1437.    (*CC->API.GetTexLevelParameterfv)(CC, target, level, pname, params);
  1438. }
  1439.  
  1440.  
  1441. void GLAPIENTRY glGetTexLevelParameteriv(CTX_ARG GLenum target, GLint level,
  1442.                                           GLenum pname, GLint *params )
  1443. {
  1444.    GET_CONTEXT;
  1445.    CHECK_CONTEXT;
  1446.    (*CC->API.GetTexLevelParameteriv)(CC, target, level, pname, params);
  1447. }
  1448.  
  1449.  
  1450. void GLAPIENTRY glGetTexParameterfv(CTX_ARG GLenum target, GLenum pname,
  1451.                                      GLfloat *params)
  1452. {
  1453.    GET_CONTEXT;
  1454.    CHECK_CONTEXT;
  1455.    (*CC->API.GetTexParameterfv)(CC, target, pname, params);
  1456. }
  1457.  
  1458.  
  1459. void GLAPIENTRY glGetTexParameteriv(CTX_ARG GLenum target, GLenum pname,
  1460.                                      GLint *params )
  1461. {
  1462.    GET_CONTEXT;
  1463.    CHECK_CONTEXT;
  1464.    (*CC->API.GetTexParameteriv)(CC, target, pname, params);
  1465. }
  1466.  
  1467.  
  1468. void GLAPIENTRY glHint(CTX_ARG GLenum target, GLenum mode )
  1469. {
  1470.    GET_CONTEXT;
  1471.    CHECK_CONTEXT;
  1472.    if (mode!=GL_DONT_CARE && mode!=GL_FASTEST && mode!=GL_NICEST) 
  1473.       (*CC->API.Error)( CC, GL_INVALID_ENUM, "glHint(mode)" );
  1474.    else 
  1475.       (*CC->API.Hint)(CC, target, mode);
  1476. }
  1477.  
  1478.  
  1479. #define INDEX( c )                \
  1480. {                        \
  1481.    GLuint count;                \
  1482.    GET_IMMEDIATE;                \
  1483.    count = IM->Count;                \
  1484.    IM->Index[count] = c;            \
  1485.    IM->Flag[count] |= VERT_INDEX;        \
  1486. }
  1487.  
  1488.  
  1489. void GLAPIENTRY glIndexd(CTX_ARG GLdouble c )
  1490. {
  1491.    INDEX( (GLuint) (GLint) c );
  1492. }
  1493.  
  1494.  
  1495. void GLAPIENTRY glIndexf(CTX_ARG GLfloat c )
  1496. {
  1497.    INDEX( (GLuint) (GLint) c );
  1498. }
  1499.  
  1500.  
  1501. void GLAPIENTRY glIndexi(CTX_ARG GLint c )
  1502. {
  1503.    INDEX( (GLuint) c );
  1504. }
  1505.  
  1506.  
  1507. void GLAPIENTRY glIndexs(CTX_ARG GLshort c )
  1508. {
  1509.    INDEX( (GLuint) c );
  1510. }
  1511.  
  1512.  
  1513. /* GL_VERSION_1_1 */
  1514. void GLAPIENTRY glIndexub(CTX_ARG GLubyte c )
  1515. {
  1516.    INDEX( (GLuint) c );
  1517. }
  1518.  
  1519.  
  1520. void GLAPIENTRY glIndexdv(CTX_ARG const GLdouble *c )
  1521. {
  1522.    INDEX( (GLuint) (GLint) *c );
  1523. }
  1524.  
  1525.  
  1526. void GLAPIENTRY glIndexfv(CTX_ARG const GLfloat *c )
  1527. {
  1528.    INDEX( (GLuint) (GLint) *c );
  1529. }
  1530.  
  1531.  
  1532. void GLAPIENTRY glIndexiv(CTX_ARG const GLint *c )
  1533. {
  1534.    INDEX( *c );
  1535. }
  1536.  
  1537.  
  1538. void GLAPIENTRY glIndexsv(CTX_ARG const GLshort *c )
  1539. {
  1540.    INDEX( (GLuint) (GLint) *c );
  1541. }
  1542.  
  1543.  
  1544. /* GL_VERSION_1_1 */
  1545. void GLAPIENTRY glIndexubv(CTX_ARG const GLubyte *c )
  1546. {
  1547.    INDEX( (GLuint) *c );
  1548. }
  1549.  
  1550.  
  1551. void GLAPIENTRY glIndexMask(CTX_ARG GLuint mask )
  1552. {
  1553.    GET_CONTEXT;
  1554.    (*CC->API.IndexMask)(CC, mask);
  1555. }
  1556.  
  1557.  
  1558.  
  1559.  
  1560. void GLAPIENTRY glInitNames(CTX_VOID )
  1561. {
  1562.    GET_CONTEXT;
  1563.    CHECK_CONTEXT;
  1564.    (*CC->API.InitNames)(CC);
  1565. }
  1566.  
  1567.  
  1568. GLboolean GLAPIENTRY glIsList(CTX_ARG GLuint list )
  1569. {
  1570.    GET_CONTEXT;
  1571.    CHECK_CONTEXT_RETURN(GL_FALSE);
  1572.    return (*CC->API.IsList)(CC, list);
  1573. }
  1574.  
  1575.  
  1576. GLboolean GLAPIENTRY glIsTexture(CTX_ARG GLuint texture )
  1577. {
  1578.    GET_CONTEXT;
  1579.    CHECK_CONTEXT_RETURN(GL_FALSE);
  1580.    return (*CC->API.IsTexture)(CC, texture);
  1581. }
  1582.  
  1583.  
  1584. void GLAPIENTRY glLightf(CTX_ARG GLenum light, GLenum pname, GLfloat param )
  1585. {
  1586.    GET_CONTEXT;
  1587.    CHECK_CONTEXT;
  1588.    (*CC->API.Lightfv)( CC, light, pname, ¶m, 1 );
  1589. }
  1590.  
  1591.  
  1592. void GLAPIENTRY glLighti(CTX_ARG GLenum light, GLenum pname, GLint param )
  1593. {
  1594.    GLfloat fparam = (GLfloat) param;
  1595.    GET_CONTEXT;
  1596.    CHECK_CONTEXT;
  1597.    (*CC->API.Lightfv)( CC, light, pname, &fparam, 1 );
  1598. }
  1599.  
  1600.  
  1601. void GLAPIENTRY glLightfv(CTX_ARG GLenum light, GLenum pname, const GLfloat *params )
  1602. {
  1603.    GET_CONTEXT;
  1604.    CHECK_CONTEXT;
  1605.    (*CC->API.Lightfv)( CC, light, pname, params, 4 );
  1606. }
  1607.  
  1608.  
  1609. void GLAPIENTRY glLightiv(CTX_ARG GLenum light, GLenum pname, const GLint *params )
  1610. {
  1611.    GLfloat fparam[4];
  1612.    GET_CONTEXT;
  1613.    CHECK_CONTEXT;
  1614.  
  1615.    switch (pname) {
  1616.       case GL_AMBIENT:
  1617.       case GL_DIFFUSE:
  1618.       case GL_SPECULAR:
  1619.          fparam[0] = INT_TO_FLOAT( params[0] );
  1620.          fparam[1] = INT_TO_FLOAT( params[1] );
  1621.          fparam[2] = INT_TO_FLOAT( params[2] );
  1622.          fparam[3] = INT_TO_FLOAT( params[3] );
  1623.          break;
  1624.       case GL_POSITION:
  1625.          fparam[0] = (GLfloat) params[0];
  1626.          fparam[1] = (GLfloat) params[1];
  1627.          fparam[2] = (GLfloat) params[2];
  1628.          fparam[3] = (GLfloat) params[3];
  1629.          break;
  1630.       case GL_SPOT_DIRECTION:
  1631.          fparam[0] = (GLfloat) params[0];
  1632.          fparam[1] = (GLfloat) params[1];
  1633.          fparam[2] = (GLfloat) params[2];
  1634.          break;
  1635.       case GL_SPOT_EXPONENT:
  1636.       case GL_SPOT_CUTOFF:
  1637.       case GL_CONSTANT_ATTENUATION:
  1638.       case GL_LINEAR_ATTENUATION:
  1639.       case GL_QUADRATIC_ATTENUATION:
  1640.          fparam[0] = (GLfloat) params[0];
  1641.          break;
  1642.       default:
  1643.          /* error will be caught later in gl_Lightfv */
  1644.          ;
  1645.    }
  1646.    (*CC->API.Lightfv)( CC, light, pname, fparam, 4 );
  1647. }
  1648.  
  1649.  
  1650. void GLAPIENTRY glLightModelf(CTX_ARG GLenum pname, GLfloat param )
  1651. {
  1652.    GET_CONTEXT;
  1653.    CHECK_CONTEXT;
  1654.    (*CC->API.LightModelfv)( CC, pname, ¶m );
  1655. }
  1656.  
  1657.  
  1658. void GLAPIENTRY glLightModeli(CTX_ARG GLenum pname, GLint param )
  1659. {
  1660.    GLfloat fparam[4];
  1661.    GET_CONTEXT;
  1662.    CHECK_CONTEXT;
  1663.    fparam[0] = (GLfloat) param;
  1664.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1665. }
  1666.  
  1667.  
  1668. void GLAPIENTRY glLightModelfv(CTX_ARG GLenum pname, const GLfloat *params )
  1669. {
  1670.    GET_CONTEXT;
  1671.    CHECK_CONTEXT;
  1672.    (*CC->API.LightModelfv)( CC, pname, params );
  1673. }
  1674.  
  1675.  
  1676. void GLAPIENTRY glLightModeliv(CTX_ARG GLenum pname, const GLint *params )
  1677. {
  1678.    GLfloat fparam[4];
  1679.    GET_CONTEXT;
  1680.    CHECK_CONTEXT;
  1681.  
  1682.    switch (pname) {
  1683.       case GL_LIGHT_MODEL_AMBIENT:
  1684.          fparam[0] = INT_TO_FLOAT( params[0] );
  1685.          fparam[1] = INT_TO_FLOAT( params[1] );
  1686.          fparam[2] = INT_TO_FLOAT( params[2] );
  1687.          fparam[3] = INT_TO_FLOAT( params[3] );
  1688.          break;
  1689.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1690.       case GL_LIGHT_MODEL_TWO_SIDE:
  1691.       case GL_LIGHT_MODEL_COLOR_CONTROL:
  1692.          fparam[0] = (GLfloat) params[0];
  1693.          break;
  1694.       default:
  1695.          /* Error will be caught later in gl_LightModelfv */
  1696.          ;
  1697.    }
  1698.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1699. }
  1700.  
  1701.  
  1702. void GLAPIENTRY glLineWidth(CTX_ARG GLfloat width )
  1703. {
  1704.    GET_CONTEXT;
  1705.    CHECK_CONTEXT;
  1706.    (*CC->API.LineWidth)(CC, width);
  1707. }
  1708.  
  1709.  
  1710. void GLAPIENTRY glLineStipple(CTX_ARG GLint factor, GLushort pattern )
  1711. {
  1712.    GET_CONTEXT;
  1713.    CHECK_CONTEXT;
  1714.    (*CC->API.LineStipple)(CC, factor, pattern);
  1715. }
  1716.  
  1717.  
  1718. void GLAPIENTRY glListBase(CTX_ARG GLuint base )
  1719. {
  1720.    GET_CONTEXT;
  1721.    CHECK_CONTEXT;
  1722.    (*CC->API.ListBase)(CC, base);
  1723. }
  1724.  
  1725.  
  1726. void GLAPIENTRY glLoadIdentity(CTX_VOID )
  1727. {
  1728.    GET_CONTEXT;
  1729.    CHECK_CONTEXT;
  1730.    (*CC->API.LoadIdentity)( CC );
  1731. }
  1732.  
  1733.  
  1734. void GLAPIENTRY glLoadMatrixd(CTX_ARG const GLdouble *m )
  1735. {
  1736.    GLfloat fm[16];
  1737.    GLuint i;
  1738.    GET_CONTEXT;
  1739.    CHECK_CONTEXT;
  1740.  
  1741.    for (i=0;i<16;i++) {
  1742.       fm[i] = (GLfloat) m[i];
  1743.    }
  1744.  
  1745.    (*CC->API.LoadMatrixf)( CC, fm );
  1746. }
  1747.  
  1748.  
  1749. void GLAPIENTRY glLoadMatrixf(CTX_ARG const GLfloat *m )
  1750. {
  1751.    GET_CONTEXT;
  1752.    CHECK_CONTEXT;
  1753.    (*CC->API.LoadMatrixf)( CC, m );
  1754. }
  1755.  
  1756.  
  1757. void GLAPIENTRY glLoadName(CTX_ARG GLuint name )
  1758. {
  1759.    GET_CONTEXT;
  1760.    CHECK_CONTEXT;
  1761.    (*CC->API.LoadName)(CC, name);
  1762. }
  1763.  
  1764.  
  1765. void GLAPIENTRY glLogicOp(CTX_ARG GLenum opcode )
  1766. {
  1767.    GET_CONTEXT;
  1768.    CHECK_CONTEXT;
  1769.    (*CC->API.LogicOp)(CC, opcode);
  1770. }
  1771.  
  1772.  
  1773.  
  1774. void GLAPIENTRY glMap1d(CTX_ARG GLenum target, GLdouble u1, GLdouble u2, GLint stride,
  1775.                          GLint order, const GLdouble *points )
  1776. {
  1777.    GLfloat *pnts;
  1778.    GLboolean retain;
  1779.    GET_CONTEXT;
  1780.    CHECK_CONTEXT;
  1781.  
  1782.    pnts = gl_copy_map_points1d( target, stride, order, points );
  1783.    retain = CC->CompileFlag;
  1784.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1785. }
  1786.  
  1787.  
  1788. void GLAPIENTRY glMap1f(CTX_ARG GLenum target, GLfloat u1, GLfloat u2, GLint stride,
  1789.                          GLint order, const GLfloat *points )
  1790. {
  1791.    GLfloat *pnts;
  1792.    GLboolean retain;
  1793.    GET_CONTEXT;
  1794.    CHECK_CONTEXT;
  1795.  
  1796.    pnts = gl_copy_map_points1f( target, stride, order, points );
  1797.    retain = CC->CompileFlag;
  1798.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1799. }
  1800.  
  1801.  
  1802. void GLAPIENTRY glMap2d(CTX_ARG GLenum target,
  1803.                          GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
  1804.                          GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
  1805.                          const GLdouble *points )
  1806. {
  1807.    GLfloat *pnts;
  1808.    GLboolean retain;
  1809.    GET_CONTEXT;
  1810.    CHECK_CONTEXT;
  1811.  
  1812.    pnts = gl_copy_map_points2d( target, ustride, uorder,
  1813.                                 vstride, vorder, points );
  1814.    retain = CC->CompileFlag;
  1815.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1816.                      v1, v2, vstride, vorder, pnts, retain );
  1817. }
  1818.  
  1819.  
  1820. void GLAPIENTRY glMap2f(CTX_ARG GLenum target,
  1821.                          GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  1822.                          GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  1823.                          const GLfloat *points )
  1824. {
  1825.    GLfloat *pnts;
  1826.    GLboolean retain;
  1827.    GET_CONTEXT;
  1828.    CHECK_CONTEXT;
  1829.  
  1830.    pnts = gl_copy_map_points2f( target, ustride, uorder,
  1831.                                 vstride, vorder, points );
  1832.    retain = CC->CompileFlag;
  1833.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1834.                      v1, v2, vstride, vorder, pnts, retain );
  1835. }
  1836.  
  1837.  
  1838. void GLAPIENTRY glMapGrid1d(CTX_ARG GLint un, GLdouble u1, GLdouble u2 )
  1839. {
  1840.    GET_CONTEXT;
  1841.    CHECK_CONTEXT;
  1842.    (*CC->API.MapGrid1f)( CC, un, (GLfloat) u1, (GLfloat) u2 );
  1843. }
  1844.  
  1845.  
  1846. void GLAPIENTRY glMapGrid1f(CTX_ARG GLint un, GLfloat u1, GLfloat u2 )
  1847. {
  1848.    GET_CONTEXT;
  1849.    CHECK_CONTEXT;
  1850.    (*CC->API.MapGrid1f)( CC, un, u1, u2 );
  1851. }
  1852.  
  1853.  
  1854. void GLAPIENTRY glMapGrid2d(CTX_ARG GLint un, GLdouble u1, GLdouble u2,
  1855.                              GLint vn, GLdouble v1, GLdouble v2 )
  1856. {
  1857.    GET_CONTEXT;
  1858.    CHECK_CONTEXT;
  1859.    (*CC->API.MapGrid2f)( CC, un, (GLfloat) u1, (GLfloat) u2,
  1860.                          vn, (GLfloat) v1, (GLfloat) v2 );
  1861. }
  1862.  
  1863.  
  1864. void GLAPIENTRY glMapGrid2f(CTX_ARG GLint un, GLfloat u1, GLfloat u2,
  1865.                              GLint vn, GLfloat v1, GLfloat v2 )
  1866. {
  1867.    GET_CONTEXT;
  1868.    CHECK_CONTEXT;
  1869.    (*CC->API.MapGrid2f)( CC, un, u1, u2, vn, v1, v2 );
  1870. }
  1871.  
  1872.  
  1873. void GLAPIENTRY glMaterialf(CTX_ARG GLenum face, GLenum pname, GLfloat param )
  1874. {
  1875.    GET_CONTEXT;
  1876.    CHECK_CONTEXT;
  1877.    gl_Materialfv( CC, face, pname, ¶m );
  1878. }
  1879.  
  1880.  
  1881.  
  1882. void GLAPIENTRY glMateriali(CTX_ARG GLenum face, GLenum pname, GLint param )
  1883. {
  1884.    GLfloat fparam[4];
  1885.    GET_CONTEXT;
  1886.    CHECK_CONTEXT;
  1887.    fparam[0] = (GLfloat) param;
  1888.    gl_Materialfv( CC, face, pname, fparam );
  1889. }
  1890.  
  1891.  
  1892. void GLAPIENTRY glMaterialfv(CTX_ARG GLenum face, GLenum pname, const GLfloat *params )
  1893. {
  1894.    GET_CONTEXT;
  1895.    CHECK_CONTEXT;
  1896.    gl_Materialfv( CC, face, pname, params );
  1897. }
  1898.  
  1899.  
  1900. void GLAPIENTRY glMaterialiv(CTX_ARG GLenum face, GLenum pname, const GLint *params )
  1901. {
  1902.    GLfloat fparam[4];
  1903.    GET_CONTEXT;
  1904.    CHECK_CONTEXT;
  1905.    switch (pname) {
  1906.       case GL_AMBIENT:
  1907.       case GL_DIFFUSE:
  1908.       case GL_SPECULAR:
  1909.       case GL_EMISSION:
  1910.       case GL_AMBIENT_AND_DIFFUSE:
  1911.          fparam[0] = INT_TO_FLOAT( params[0] );
  1912.          fparam[1] = INT_TO_FLOAT( params[1] );
  1913.          fparam[2] = INT_TO_FLOAT( params[2] );
  1914.          fparam[3] = INT_TO_FLOAT( params[3] );
  1915.          break;
  1916.       case GL_SHININESS:
  1917.          fparam[0] = (GLfloat) params[0];
  1918.          break;
  1919.       case GL_COLOR_INDEXES:
  1920.          fparam[0] = (GLfloat) params[0];
  1921.          fparam[1] = (GLfloat) params[1];
  1922.          fparam[2] = (GLfloat) params[2];
  1923.          break;
  1924.       default:
  1925.          /* Error will be caught later in gl_Materialfv */
  1926.          ;
  1927.    }
  1928.    gl_Materialfv( CC, face, pname, fparam );
  1929. }
  1930.  
  1931.  
  1932. void GLAPIENTRY glMatrixMode(CTX_ARG GLenum mode )
  1933. {
  1934.    GET_CONTEXT;
  1935.    CHECK_CONTEXT;
  1936.    (*CC->API.MatrixMode)( CC, mode );
  1937. }
  1938.  
  1939.  
  1940. void GLAPIENTRY glMultMatrixd(CTX_ARG const GLdouble *m )
  1941. {
  1942.    GLfloat fm[16];
  1943.    GLuint i;
  1944.    GET_CONTEXT;
  1945.    CHECK_CONTEXT;
  1946.  
  1947.    for (i=0;i<16;i++) {
  1948.       fm[i] = (GLfloat) m[i];
  1949.    }
  1950.  
  1951.    (*CC->API.MultMatrixf)( CC, fm );
  1952. }
  1953.  
  1954.  
  1955. void GLAPIENTRY glMultMatrixf(CTX_ARG const GLfloat *m )
  1956. {
  1957.    GET_CONTEXT;
  1958.    CHECK_CONTEXT;
  1959.    (*CC->API.MultMatrixf)( CC, m );
  1960. }
  1961.  
  1962.  
  1963. void GLAPIENTRY glNewList(CTX_ARG GLuint list, GLenum mode )
  1964. {
  1965.    GET_CONTEXT;
  1966.    CHECK_CONTEXT;
  1967.    (*CC->API.NewList)(CC, list, mode);
  1968. }
  1969.  
  1970.  
  1971. /* KW: Now that we build buffers for display lists the same way we
  1972.  *     fill the vb, we can do the work here without a second function
  1973.  *     call.  The Flag member allows the identification of missing
  1974.  *     (ie shared) normals.
  1975.  */
  1976. #define NORMAL( x,y,z )                \
  1977. {                        \
  1978.    GLuint count;                \
  1979.    GLfloat *normal;                \
  1980.    GET_IMMEDIATE;                \
  1981.    count = IM->Count;                \
  1982.    IM->Flag[count] |= VERT_NORM;        \
  1983.    normal = IM->Normal[count];            \
  1984.    ASSIGN_3V(normal, x,y,z);            \
  1985. }
  1986.  
  1987.  
  1988. void GLAPIENTRY glNormal3b(CTX_ARG GLbyte nx, GLbyte ny, GLbyte nz )
  1989. {
  1990.    NORMAL( BYTE_TO_FLOAT(nx),
  1991.        BYTE_TO_FLOAT(ny),
  1992.        BYTE_TO_FLOAT(nz) );
  1993. }
  1994.  
  1995.  
  1996. void GLAPIENTRY glNormal3d(CTX_ARG GLdouble nx, GLdouble ny, GLdouble nz )
  1997. {
  1998.    NORMAL(nx,ny,nz);
  1999. }
  2000.  
  2001.  
  2002. void GLAPIENTRY glNormal3f(CTX_ARG GLfloat nx, GLfloat ny, GLfloat nz )
  2003. {
  2004.    NORMAL(nx,ny,nz);
  2005. }
  2006.  
  2007.  
  2008. void GLAPIENTRY glNormal3i(CTX_ARG GLint nx, GLint ny, GLint nz )
  2009. {
  2010.    NORMAL( INT_TO_FLOAT(nx),
  2011.        INT_TO_FLOAT(ny),
  2012.        INT_TO_FLOAT(nz) );
  2013. }
  2014.  
  2015.  
  2016. void GLAPIENTRY glNormal3s(CTX_ARG GLshort nx, GLshort ny, GLshort nz )
  2017. {
  2018.    NORMAL( SHORT_TO_FLOAT(nx),
  2019.        SHORT_TO_FLOAT(ny),
  2020.        SHORT_TO_FLOAT(nz) );
  2021. }
  2022.  
  2023.  
  2024. void GLAPIENTRY glNormal3bv(CTX_ARG const GLbyte *v )
  2025. {
  2026.    NORMAL( BYTE_TO_FLOAT(v[0]),
  2027.        BYTE_TO_FLOAT(v[1]),
  2028.        BYTE_TO_FLOAT(v[2]) );
  2029. }
  2030.  
  2031.  
  2032. void GLAPIENTRY glNormal3dv(CTX_ARG const GLdouble *v )
  2033. {
  2034.    NORMAL( v[0], v[1], v[2] );
  2035. }
  2036.  
  2037.  
  2038. void GLAPIENTRY glNormal3fv(CTX_ARG const GLfloat *v )
  2039. {
  2040.    NORMAL( v[0], v[1], v[2] );
  2041. }
  2042.  
  2043.  
  2044. void GLAPIENTRY glNormal3iv(CTX_ARG const GLint *v )
  2045. {
  2046.    NORMAL( INT_TO_FLOAT(v[0]),
  2047.        INT_TO_FLOAT(v[1]), 
  2048.        INT_TO_FLOAT(v[2]) );
  2049. }
  2050.  
  2051.  
  2052. void GLAPIENTRY glNormal3sv(CTX_ARG const GLshort *v )
  2053. {
  2054.    NORMAL( SHORT_TO_FLOAT(v[0]),
  2055.        SHORT_TO_FLOAT(v[1]),
  2056.        SHORT_TO_FLOAT(v[2]) );
  2057. }
  2058.  
  2059.