home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / mesa / src / api1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-31  |  37.0 KB  |  1,869 lines
  1. /* $Id: api1.c,v 1.3 1997/11/05 03:25:52 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.5
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: api1.c,v $
  26.  * Revision 1.3  1997/11/05 03:25:52  brianp
  27.  * fixed null bitmap problem in glBitmap
  28.  *
  29.  * Revision 1.2  1997/09/27 00:15:05  brianp
  30.  * added GL_EXT_paletted_texture extension
  31.  *
  32.  * Revision 1.1  1997/08/22 01:42:11  brianp
  33.  * Initial revision
  34.  *
  35.  */
  36.  
  37.  
  38. #ifdef PC_HEADER
  39. #include "all.h"
  40. #else
  41. #include <stdio.h>
  42. #include <stdlib.h>
  43. #include "api.h"
  44. #include "bitmap.h"
  45. #include "context.h"
  46.  
  47. #include "drawpix.h"
  48.  
  49. #include "eval.h"
  50. #include "image.h"
  51. #include "macros.h"
  52. #include "matrix.h"
  53. #include "teximage.h"
  54. #include "types.h"
  55. #include "vb.h"
  56. #endif
  57.  
  58.  
  59.  
  60.  
  61. void APIENTRY glAccum( GLenum op, GLfloat value )
  62. {
  63.    GET_CONTEXT;
  64.    CHECK_CONTEXT;
  65.    (*CC->API.Accum)(CC, op, value);
  66. }
  67.  
  68.  
  69. void APIENTRY glAlphaFunc( GLenum func, GLclampf ref )
  70. {
  71.    GET_CONTEXT;
  72.    CHECK_CONTEXT;
  73.    (*CC->API.AlphaFunc)(CC, func, ref);
  74. }
  75.  
  76.  
  77. GLboolean APIENTRY glAreTexturesResident( GLsizei n, const GLuint *textures,
  78.                                  GLboolean *residences )
  79. {
  80.    GET_CONTEXT;
  81.    CHECK_CONTEXT_RETURN(GL_FALSE);
  82.    return (*CC->API.AreTexturesResident)(CC, n, textures, residences);
  83. }
  84.  
  85.  
  86. void APIENTRY glArrayElement( GLint i )
  87. {
  88.    GET_CONTEXT;
  89.    CHECK_CONTEXT;
  90.    (*CC->API.ArrayElement)(CC, i);
  91. }
  92.  
  93.  
  94. void APIENTRY glBegin( GLenum mode )
  95. {
  96.    GET_CONTEXT;
  97.    CHECK_CONTEXT;
  98.    (*CC->API.Begin)( CC, mode );
  99. }
  100.  
  101.  
  102. void APIENTRY glBindTexture( GLenum target, GLuint texture )
  103. {
  104.    GET_CONTEXT;
  105.    CHECK_CONTEXT;
  106.    (*CC->API.BindTexture)(CC, target, texture);
  107. }
  108.  
  109.  
  110. void APIENTRY glBitmap( GLsizei width, GLsizei height,
  111.            GLfloat xorig, GLfloat yorig,
  112.            GLfloat xmove, GLfloat ymove,
  113.            const GLubyte *bitmap )
  114. {
  115.    GET_CONTEXT;
  116.    CHECK_CONTEXT;
  117.    if (!CC->CompileFlag) {
  118.       /* execute only, try optimized case where no unpacking needed */
  119.       if (   CC->Unpack.LsbFirst==GL_FALSE
  120.       && CC->Unpack.Alignment==1
  121.       && CC->Unpack.RowLength==0
  122.       && CC->Unpack.SkipPixels==0
  123.       && CC->Unpack.SkipRows==0) {
  124.      /* Special case: no unpacking needed */
  125.      struct gl_image image;
  126.      image.Width = width;
  127.      image.Height = height;
  128.      image.Components = 0;
  129.      image.Type = GL_BITMAP;
  130.      image.Format = GL_COLOR_INDEX;
  131.      image.Data = (GLvoid *) bitmap;
  132.      (*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
  133.                  xmove, ymove, &image );
  134.       }
  135.       else {
  136.      struct gl_image *image;
  137.      image = gl_unpack_bitmap( CC, width, height, bitmap );
  138.      (*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
  139.                  xmove, ymove, image );
  140.      if (image) {
  141.         gl_free_image( image );
  142.      }
  143.       }
  144.    }
  145.    else {
  146.       /* compile and maybe execute */
  147.       struct gl_image *image;
  148.       image = gl_unpack_bitmap( CC, width, height, bitmap );
  149.       (*CC->API.Bitmap)(CC, width, height, xorig, yorig, xmove, ymove, image );
  150.    }
  151. }
  152.  
  153.  
  154. void APIENTRY glBlendFunc( GLenum sfactor, GLenum dfactor )
  155. {
  156.    GET_CONTEXT;
  157.    CHECK_CONTEXT;
  158.    (*CC->API.BlendFunc)(CC, sfactor, dfactor);
  159. }
  160.  
  161.  
  162. void APIENTRY glCallList( GLuint list )
  163. {
  164.    GET_CONTEXT;
  165.    CHECK_CONTEXT;
  166.    (*CC->API.CallList)(CC, list);
  167. }
  168.  
  169.  
  170. void APIENTRY glCallLists( 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 APIENTRY glClear( GLbitfield mask )
  179. {
  180.    GET_CONTEXT;
  181.    CHECK_CONTEXT;
  182.    (*CC->API.Clear)(CC, mask);
  183. }
  184.  
  185.  
  186. void APIENTRY glClearAccum( 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 APIENTRY glClearIndex( GLfloat c )
  197. {
  198.    GET_CONTEXT;
  199.    CHECK_CONTEXT;
  200.    (*CC->API.ClearIndex)(CC, c);
  201. }
  202.  
  203.  
  204. void APIENTRY glClearColor( GLclampf red,
  205.               GLclampf green,
  206.               GLclampf blue,
  207.               GLclampf alpha )
  208. {
  209.    GET_CONTEXT;
  210.    CHECK_CONTEXT;
  211.    (*CC->API.ClearColor)(CC, red, green, blue, alpha);
  212. }
  213.  
  214.  
  215. void APIENTRY glClearDepth( GLclampd depth )
  216. {
  217.    GET_CONTEXT;
  218.    CHECK_CONTEXT;
  219.    (*CC->API.ClearDepth)( CC, depth );
  220. }
  221.  
  222.  
  223. void APIENTRY glClearStencil( GLint s )
  224. {
  225.    GET_CONTEXT;
  226.    CHECK_CONTEXT;
  227.    (*CC->API.ClearStencil)(CC, s);
  228. }
  229.  
  230.  
  231. void APIENTRY glClipPlane( GLenum plane, const GLdouble *equation )
  232. {
  233.    GLfloat eq[4];
  234.    GET_CONTEXT;
  235.    CHECK_CONTEXT;
  236.    eq[0] = (GLfloat) equation[0];
  237.    eq[1] = (GLfloat) equation[1];
  238.    eq[2] = (GLfloat) equation[2];
  239.    eq[3] = (GLfloat) equation[3];
  240.    (*CC->API.ClipPlane)(CC, plane, eq );
  241. }
  242.  
  243.  
  244. void APIENTRY glColor3b( GLbyte red, GLbyte green, GLbyte blue )
  245. {
  246.    GET_CONTEXT;
  247.    (*CC->API.Color3f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  248.                BYTE_TO_FLOAT(blue) );
  249. }
  250.  
  251.  
  252. void APIENTRY glColor3d( GLdouble red, GLdouble green, GLdouble blue )
  253. {
  254.    GET_CONTEXT;
  255.    (*CC->API.Color3f)( CC, (GLfloat) red, (GLfloat) green, (GLfloat) blue );
  256. }
  257.  
  258.  
  259. void APIENTRY glColor3f( GLfloat red, GLfloat green, GLfloat blue )
  260. {
  261.    GET_CONTEXT;
  262.    (*CC->API.Color3f)( CC, red, green, blue );
  263. }
  264.  
  265.  
  266. void APIENTRY glColor3i( GLint red, GLint green, GLint blue )
  267. {
  268.    GET_CONTEXT;
  269.    (*CC->API.Color3f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  270.                INT_TO_FLOAT(blue) );
  271. }
  272.  
  273.  
  274. void APIENTRY glColor3s( GLshort red, GLshort green, GLshort blue )
  275. {
  276.    GET_CONTEXT;
  277.    (*CC->API.Color3f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  278.                SHORT_TO_FLOAT(blue) );
  279. }
  280.  
  281.  
  282. void APIENTRY glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
  283. {
  284.    GET_CONTEXT;
  285.    (*CC->API.Color4ub)( CC, red, green, blue, 255 );
  286. }
  287.  
  288.  
  289. void APIENTRY glColor3ui( GLuint red, GLuint green, GLuint blue )
  290. {
  291.    GET_CONTEXT;
  292.    (*CC->API.Color3f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
  293.                UINT_TO_FLOAT(blue) );
  294. }
  295.  
  296.  
  297. void APIENTRY glColor3us( GLushort red, GLushort green, GLushort blue )
  298. {
  299.    GET_CONTEXT;
  300.    (*CC->API.Color3f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
  301.                USHORT_TO_FLOAT(blue) );
  302. }
  303.  
  304.  
  305. void APIENTRY glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
  306. {
  307.    GET_CONTEXT;
  308.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  309.                BYTE_TO_FLOAT(blue), BYTE_TO_FLOAT(alpha) );
  310. }
  311.  
  312.  
  313. void APIENTRY glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
  314. {
  315.    GET_CONTEXT;
  316.    (*CC->API.Color4f)( CC, (GLfloat) red, (GLfloat) green,
  317.                (GLfloat) blue, (GLfloat) alpha );
  318. }
  319.  
  320.  
  321. void APIENTRY glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
  322. {
  323.    GET_CONTEXT;
  324.    (*CC->API.Color4f)( CC, red, green, blue, alpha );
  325. }
  326.  
  327. void APIENTRY glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
  328. {
  329.    GET_CONTEXT;
  330.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  331.                INT_TO_FLOAT(blue), INT_TO_FLOAT(alpha) );
  332. }
  333.  
  334.  
  335. void APIENTRY glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
  336. {
  337.    GET_CONTEXT;
  338.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  339.                SHORT_TO_FLOAT(blue), SHORT_TO_FLOAT(alpha) );
  340. }
  341.  
  342. void APIENTRY glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
  343. {
  344.    GET_CONTEXT;
  345.    (*CC->API.Color4ub)( CC, red, green, blue, alpha );
  346. }
  347.  
  348. void APIENTRY glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
  349. {
  350.    GET_CONTEXT;
  351.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
  352.                UINT_TO_FLOAT(blue), UINT_TO_FLOAT(alpha) );
  353. }
  354.  
  355. void APIENTRY glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
  356. {
  357.    GET_CONTEXT;
  358.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
  359.                USHORT_TO_FLOAT(blue), USHORT_TO_FLOAT(alpha) );
  360. }
  361.  
  362.  
  363. void APIENTRY glColor3bv( const GLbyte *v )
  364. {
  365.    GET_CONTEXT;
  366.    (*CC->API.Color3f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
  367.                BYTE_TO_FLOAT(v[2]) );
  368. }
  369.  
  370.  
  371. void APIENTRY glColor3dv( const GLdouble *v )
  372. {
  373.    GET_CONTEXT;
  374.    (*CC->API.Color3f)( CC, (GLdouble) v[0], (GLdouble) v[1], (GLdouble) v[2] );
  375. }
  376.  
  377.  
  378. void APIENTRY glColor3fv( const GLfloat *v )
  379. {
  380.    GET_CONTEXT;
  381.    (*CC->API.Color3fv)( CC, v );
  382. }
  383.  
  384.  
  385. void APIENTRY glColor3iv( const GLint *v )
  386. {
  387.    GET_CONTEXT;
  388.    (*CC->API.Color3f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
  389.                INT_TO_FLOAT(v[2]) );
  390. }
  391.  
  392.  
  393. void APIENTRY glColor3sv( const GLshort *v )
  394. {
  395.    GET_CONTEXT;
  396.    (*CC->API.Color3f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
  397.                SHORT_TO_FLOAT(v[2]) );
  398. }
  399.  
  400.  
  401. void APIENTRY glColor3ubv( const GLubyte *v )
  402. {
  403.    GET_CONTEXT;
  404.    (*CC->API.Color4ub)( CC, v[0], v[1], v[2], 255 );
  405. }
  406.  
  407.  
  408. void APIENTRY glColor3uiv( const GLuint *v )
  409. {
  410.    GET_CONTEXT;
  411.    (*CC->API.Color3f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
  412.                UINT_TO_FLOAT(v[2]) );
  413. }
  414.  
  415.  
  416. void APIENTRY glColor3usv( const GLushort *v )
  417. {
  418.    GET_CONTEXT;
  419.    (*CC->API.Color3f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
  420.                USHORT_TO_FLOAT(v[2]) );
  421.  
  422. }
  423.  
  424.  
  425. void APIENTRY glColor4bv( const GLbyte *v )
  426. {
  427.    GET_CONTEXT;
  428.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
  429.                BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]) );
  430. }
  431.  
  432.  
  433. void APIENTRY glColor4dv( const GLdouble *v )
  434. {
  435.    GET_CONTEXT;
  436.    (*CC->API.Color4f)( CC, (GLdouble) v[0], (GLdouble) v[1],
  437.                (GLdouble) v[2], (GLdouble) v[3] );
  438. }
  439.  
  440.  
  441. void APIENTRY glColor4fv( const GLfloat *v )
  442. {
  443.    GET_CONTEXT;
  444.    (*CC->API.Color4f)( CC, v[0], v[1], v[2], v[3] );
  445. }
  446.  
  447.  
  448. void APIENTRY glColor4iv( const GLint *v )
  449. {
  450.    GET_CONTEXT;
  451.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
  452.                INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]) );
  453. }
  454.  
  455.  
  456. void APIENTRY glColor4sv( const GLshort *v )
  457. {
  458.    GET_CONTEXT;
  459.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
  460.                SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]) );
  461. }
  462.  
  463.  
  464. void APIENTRY glColor4ubv( const GLubyte *v )
  465. {
  466.    GET_CONTEXT;
  467.    (*CC->API.Color4ubv)( CC, v );
  468. }
  469.  
  470.  
  471. void APIENTRY glColor4uiv( const GLuint *v )
  472. {
  473.    GET_CONTEXT;
  474.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
  475.                UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]) );
  476. }
  477.  
  478.  
  479. void APIENTRY glColor4usv( const GLushort *v )
  480. {
  481.    GET_CONTEXT;
  482.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
  483.                USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]) );
  484. }
  485.  
  486.  
  487. void APIENTRY glColorMask( GLboolean red, GLboolean green,
  488.              GLboolean blue, GLboolean alpha )
  489. {
  490.    GET_CONTEXT;
  491.    CHECK_CONTEXT;
  492.    (*CC->API.ColorMask)(CC, red, green, blue, alpha);
  493. }
  494.  
  495.  
  496. void APIENTRY glColorMaterial( GLenum face, GLenum mode )
  497. {
  498.    GET_CONTEXT;
  499.    CHECK_CONTEXT;
  500.    (*CC->API.ColorMaterial)(CC, face, mode);
  501. }
  502.  
  503.  
  504. void APIENTRY glColorPointer( GLint size, GLenum type, GLsizei stride,
  505.                      const GLvoid *ptr )
  506. {
  507.    GET_CONTEXT;
  508.    CHECK_CONTEXT;
  509.    (*CC->API.ColorPointer)(CC, size, type, stride, ptr);
  510. }
  511.  
  512.  
  513. void APIENTRY glColorTableEXT( GLenum target, GLenum internalFormat,
  514.                    GLsizei width, GLenum format, GLenum type,
  515.                    const GLvoid *table )
  516. {
  517.    struct gl_image *image;
  518.    GET_CONTEXT;
  519.    CHECK_CONTEXT;
  520.    image = gl_unpack_image( CC, width, 1, format, type, table );
  521.    (*CC->API.ColorTable)( CC, target, internalFormat, image );
  522.    if (image->RefCount == 0)
  523.       gl_free_image(image);
  524. }
  525.  
  526.  
  527. void APIENTRY glColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, 
  528.                   GLenum format, GLenum type,
  529.                   const GLvoid *data )
  530. {
  531.    struct gl_image *image;
  532.    GET_CONTEXT;
  533.    CHECK_CONTEXT;
  534.    image = gl_unpack_image( CC, count, 1, format, type, data );
  535.    (*CC->API.ColorSubTable)( CC, target, start, image );
  536.    if (image->RefCount == 0)
  537.       gl_free_image(image);
  538. }
  539.  
  540.  
  541.  
  542. void APIENTRY glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height,
  543.               GLenum type )
  544. {
  545.    GET_CONTEXT;
  546.    CHECK_CONTEXT;
  547.    (*CC->API.CopyPixels)(CC, x, y, width, height, type);
  548. }
  549.  
  550.  
  551. void APIENTRY glCopyTexImage1D( GLenum target, GLint level,
  552.                 GLenum internalformat,
  553.                 GLint x, GLint y,
  554.                 GLsizei width, GLint border )
  555. {
  556.    GET_CONTEXT;
  557.    CHECK_CONTEXT;
  558.    (*CC->API.CopyTexImage1D)( CC, target, level, internalformat,
  559.                                  x, y, width, border );
  560. }
  561.  
  562.  
  563. void APIENTRY glCopyTexImage2D( GLenum target, GLint level,
  564.                 GLenum internalformat,
  565.                 GLint x, GLint y,
  566.                 GLsizei width, GLsizei height, GLint border )
  567. {
  568.    GET_CONTEXT;
  569.    CHECK_CONTEXT;
  570.    (*CC->API.CopyTexImage2D)( CC, target, level, internalformat,
  571.                   x, y, width, height, border );
  572. }
  573.  
  574.  
  575. void APIENTRY glCopyTexSubImage1D( GLenum target, GLint level,
  576.                    GLint xoffset, GLint x, GLint y,
  577.                    GLsizei width )
  578. {
  579.    GET_CONTEXT;
  580.    CHECK_CONTEXT;
  581.    (*CC->API.CopyTexSubImage1D)( CC, target, level, xoffset, x, y, width );
  582. }
  583.  
  584.  
  585. void APIENTRY glCopyTexSubImage2D( GLenum target, GLint level,
  586.                    GLint xoffset, GLint yoffset,
  587.                    GLint x, GLint y,
  588.                    GLsizei width, GLsizei height )
  589. {
  590.    GET_CONTEXT;
  591.    CHECK_CONTEXT;
  592.    (*CC->API.CopyTexSubImage2D)( CC, target, level, xoffset, yoffset,
  593.                  x, y, width, height );
  594. }
  595.  
  596.  
  597.  
  598. void APIENTRY glCullFace( GLenum mode )
  599. {
  600.    GET_CONTEXT;
  601.    CHECK_CONTEXT;
  602.    (*CC->API.CullFace)(CC, mode);
  603. }
  604.  
  605.  
  606. void APIENTRY glDepthFunc( GLenum func )
  607. {
  608.    GET_CONTEXT;
  609.    CHECK_CONTEXT;
  610.    (*CC->API.DepthFunc)( CC, func );
  611. }
  612.  
  613.  
  614. void APIENTRY glDepthMask( GLboolean flag )
  615. {
  616.    GET_CONTEXT;
  617.    CHECK_CONTEXT;
  618.    (*CC->API.DepthMask)( CC, flag );
  619. }
  620.  
  621.  
  622. void APIENTRY glDepthRange( GLclampd near_val, GLclampd far_val )
  623. {
  624.    GET_CONTEXT;
  625.    CHECK_CONTEXT;
  626.    (*CC->API.DepthRange)( CC, near_val, far_val );
  627. }
  628.  
  629.  
  630. void APIENTRY glDeleteLists( GLuint list, GLsizei range )
  631. {
  632.    GET_CONTEXT;
  633.    CHECK_CONTEXT;
  634.    (*CC->API.DeleteLists)(CC, list, range);
  635. }
  636.  
  637.  
  638. void APIENTRY glDeleteTextures( GLsizei n, const GLuint *textures)
  639. {
  640.    GET_CONTEXT;
  641.    CHECK_CONTEXT;
  642.    (*CC->API.DeleteTextures)(CC, n, textures);
  643. }
  644.  
  645.  
  646. void APIENTRY glDisable( GLenum cap )
  647. {
  648.    GET_CONTEXT;
  649.    CHECK_CONTEXT;
  650.    (*CC->API.Disable)( CC, cap );
  651. }
  652.  
  653.  
  654. void APIENTRY glDisableClientState( GLenum cap )
  655. {
  656.    GET_CONTEXT;
  657.    CHECK_CONTEXT;
  658.    (*CC->API.DisableClientState)( CC, cap );
  659. }
  660.  
  661.  
  662. void APIENTRY glDrawArrays( GLenum mode, GLint first, GLsizei count )
  663. {
  664.    GET_CONTEXT;
  665.    CHECK_CONTEXT;
  666.    (*CC->API.DrawArrays)(CC, mode, first, count);
  667. }
  668.  
  669.  
  670. void APIENTRY glDrawBuffer( GLenum mode )
  671. {
  672.    GET_CONTEXT;
  673.    CHECK_CONTEXT;
  674.    (*CC->API.DrawBuffer)(CC, mode);
  675. }
  676.  
  677.  
  678. void APIENTRY glDrawElements( GLenum mode, GLsizei count,
  679.                   GLenum type, const GLvoid *indices )
  680. {
  681.    GET_CONTEXT;
  682.    CHECK_CONTEXT;
  683.    (*CC->API.DrawElements)( CC, mode, count, type, indices );
  684. }
  685.  
  686.  
  687. void APIENTRY glDrawPixels( GLsizei width, GLsizei height,
  688.                 GLenum format, GLenum type, const GLvoid *pixels )
  689. {
  690.    GET_CONTEXT;
  691.    CHECK_CONTEXT;
  692.    (*CC->API.DrawPixels)( CC, width, height, format, type, pixels );
  693. }
  694.  
  695.  
  696. void APIENTRY glEnable( GLenum cap )
  697. {
  698.    GET_CONTEXT;
  699.    CHECK_CONTEXT;
  700.    (*CC->API.Enable)( CC, cap );
  701. }
  702.  
  703.  
  704. void APIENTRY glEnableClientState( GLenum cap )
  705. {
  706.    GET_CONTEXT;
  707.    CHECK_CONTEXT;
  708.    (*CC->API.EnableClientState)( CC, cap );
  709. }
  710.  
  711.  
  712. void APIENTRY glEnd( void )
  713. {
  714.    GET_CONTEXT;
  715.    CHECK_CONTEXT;
  716.    (*CC->API.End)( CC );
  717. }
  718.  
  719.  
  720. void APIENTRY glEndList( void )
  721. {
  722.    GET_CONTEXT;
  723.    CHECK_CONTEXT;
  724.    (*CC->API.EndList)(CC);
  725. }
  726.  
  727.  
  728.  
  729.  
  730. void APIENTRY glEvalCoord1d( GLdouble u )
  731. {
  732.    GET_CONTEXT;
  733.    CHECK_CONTEXT;
  734.    (*CC->API.EvalCoord1f)( CC, (GLfloat) u );
  735. }
  736.  
  737.  
  738. void APIENTRY glEvalCoord1f( GLfloat u )
  739. {
  740.    GET_CONTEXT;
  741.    CHECK_CONTEXT;
  742.    (*CC->API.EvalCoord1f)( CC, u );
  743. }
  744.  
  745.  
  746. void APIENTRY glEvalCoord1dv( const GLdouble *u )
  747. {
  748.    GET_CONTEXT;
  749.    CHECK_CONTEXT;
  750.    (*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
  751. }
  752.  
  753.  
  754. void APIENTRY glEvalCoord1fv( const GLfloat *u )
  755. {
  756.    GET_CONTEXT;
  757.    CHECK_CONTEXT;
  758.    (*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
  759. }
  760.  
  761.  
  762. void APIENTRY glEvalCoord2d( GLdouble u, GLdouble v )
  763. {
  764.    GET_CONTEXT;
  765.    CHECK_CONTEXT;
  766.    (*CC->API.EvalCoord2f)( CC, (GLfloat) u, (GLfloat) v );
  767. }
  768.  
  769.  
  770. void APIENTRY glEvalCoord2f( GLfloat u, GLfloat v )
  771. {
  772.    GET_CONTEXT;
  773.    CHECK_CONTEXT;
  774.    (*CC->API.EvalCoord2f)( CC, u, v );
  775. }
  776.  
  777.  
  778. void APIENTRY glEvalCoord2dv( const GLdouble *u )
  779. {
  780.    GET_CONTEXT;
  781.    CHECK_CONTEXT;
  782.    (*CC->API.EvalCoord2f)( CC, (GLfloat) u[0], (GLfloat) u[1] );
  783. }
  784.  
  785.  
  786. void APIENTRY glEvalCoord2fv( const GLfloat *u )
  787. {
  788.    GET_CONTEXT;
  789.    CHECK_CONTEXT;
  790.    (*CC->API.EvalCoord2f)( CC, u[0], u[1] );
  791. }
  792.  
  793.  
  794. void APIENTRY glEvalPoint1( GLint i )
  795. {
  796.    GET_CONTEXT;
  797.    CHECK_CONTEXT;
  798.    (*CC->API.EvalPoint1)( CC, i );
  799. }
  800.  
  801.  
  802. void APIENTRY glEvalPoint2( GLint i, GLint j )
  803. {
  804.    GET_CONTEXT;
  805.    CHECK_CONTEXT;
  806.    (*CC->API.EvalPoint2)( CC, i, j );
  807. }
  808.  
  809.  
  810. void APIENTRY glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
  811. {
  812.    GET_CONTEXT;
  813.    CHECK_CONTEXT;
  814.    (*CC->API.EvalMesh1)( CC, mode, i1, i2 );
  815. }
  816.  
  817.  
  818. void APIENTRY glEdgeFlag( GLboolean flag )
  819. {
  820.    GET_CONTEXT;
  821.    CHECK_CONTEXT;
  822.    (*CC->API.EdgeFlag)(CC, flag);
  823. }
  824.  
  825.  
  826. void APIENTRY glEdgeFlagv( const GLboolean *flag )
  827. {
  828.    GET_CONTEXT;
  829.    CHECK_CONTEXT;
  830.    (*CC->API.EdgeFlag)(CC, *flag);
  831. }
  832.  
  833.  
  834. void APIENTRY glEdgeFlagPointer( GLsizei stride, const GLboolean *ptr )
  835. {
  836.    GET_CONTEXT;
  837.    CHECK_CONTEXT;
  838.    (*CC->API.EdgeFlagPointer)(CC, stride, ptr);
  839. }
  840.  
  841.  
  842. void APIENTRY glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
  843. {
  844.    GET_CONTEXT;
  845.    CHECK_CONTEXT;
  846.    (*CC->API.EvalMesh2)( CC, mode, i1, i2, j1, j2 );
  847. }
  848.  
  849.  
  850. void APIENTRY glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
  851. {
  852.    GET_CONTEXT;
  853.    CHECK_CONTEXT;
  854.    (*CC->API.FeedbackBuffer)(CC, size, type, buffer);
  855. }
  856.  
  857.  
  858. void APIENTRY glFinish( void )
  859. {
  860.    GET_CONTEXT;
  861.    CHECK_CONTEXT;
  862.    (*CC->API.Finish)(CC);
  863. }
  864.  
  865.  
  866. void APIENTRY glFlush( void )
  867. {
  868.    GET_CONTEXT;
  869.    CHECK_CONTEXT;
  870.    (*CC->API.Flush)(CC);
  871. }
  872.  
  873.  
  874. void APIENTRY glFogf( GLenum pname, GLfloat param )
  875. {
  876.    GET_CONTEXT;
  877.    CHECK_CONTEXT;
  878.    (*CC->API.Fogfv)(CC, pname, ¶m);
  879. }
  880.  
  881.  
  882. void APIENTRY glFogi( GLenum pname, GLint param )
  883. {
  884.    GLfloat fparam = (GLfloat) param;
  885.    GET_CONTEXT;
  886.    CHECK_CONTEXT;
  887.    (*CC->API.Fogfv)(CC, pname, &fparam);
  888. }
  889.  
  890.  
  891. void APIENTRY glFogfv( GLenum pname, const GLfloat *params )
  892. {
  893.    GET_CONTEXT;
  894.    CHECK_CONTEXT;
  895.    (*CC->API.Fogfv)(CC, pname, params);
  896. }
  897.  
  898.  
  899. void APIENTRY glFogiv( GLenum pname, const GLint *params )
  900. {
  901.    GLfloat p[4];
  902.    GET_CONTEXT;
  903.    CHECK_CONTEXT;
  904.  
  905.    switch (pname) {
  906.       case GL_FOG_MODE:
  907.       case GL_FOG_DENSITY:
  908.       case GL_FOG_START:
  909.       case GL_FOG_END:
  910.       case GL_FOG_INDEX:
  911.      p[0] = (GLfloat) *params;
  912.      break;
  913.       case GL_FOG_COLOR:
  914.      p[0] = INT_TO_FLOAT( params[0] );
  915.      p[1] = INT_TO_FLOAT( params[1] );
  916.      p[2] = INT_TO_FLOAT( params[2] );
  917.      p[3] = INT_TO_FLOAT( params[3] );
  918.      break;
  919.       default:
  920.      /* Error will be caught later in gl_Fogfv */
  921.      ;
  922.    }
  923.    (*CC->API.Fogfv)( CC, pname, p );
  924. }
  925.  
  926.  
  927.  
  928. void APIENTRY glFrontFace( GLenum mode )
  929. {
  930.    GET_CONTEXT;
  931.    CHECK_CONTEXT;
  932.    (*CC->API.FrontFace)(CC, mode);
  933. }
  934.  
  935.  
  936. void APIENTRY glFrustum( GLdouble left, GLdouble right,
  937.              GLdouble bottom, GLdouble top,
  938.              GLdouble nearval, GLdouble farval )
  939. {
  940.    GET_CONTEXT;
  941.    CHECK_CONTEXT;
  942.    (*CC->API.Frustum)(CC, left, right, bottom, top, nearval, farval);
  943. }
  944.  
  945.  
  946. GLuint APIENTRY glGenLists( GLsizei range )
  947. {
  948.    GET_CONTEXT;
  949.    CHECK_CONTEXT_RETURN(0);
  950.    return (*CC->API.GenLists)(CC, range);
  951. }
  952.  
  953.  
  954. void APIENTRY glGenTextures( GLsizei n, GLuint *textures )
  955. {
  956.    GET_CONTEXT;
  957.    CHECK_CONTEXT;
  958.    (*CC->API.GenTextures)(CC, n, textures);
  959. }
  960.  
  961.  
  962. void APIENTRY glGetBooleanv( GLenum pname, GLboolean *params )
  963. {
  964.    GET_CONTEXT;
  965.    CHECK_CONTEXT;
  966.    (*CC->API.GetBooleanv)(CC, pname, params);
  967. }
  968.  
  969.  
  970. void APIENTRY glGetClipPlane( GLenum plane, GLdouble *equation )
  971. {
  972.    GET_CONTEXT;
  973.    CHECK_CONTEXT;
  974.    (*CC->API.GetClipPlane)(CC, plane, equation);
  975. }
  976.  
  977.  
  978. void APIENTRY glGetColorTableEXT( GLenum target, GLenum format,
  979.                   GLenum type, GLvoid *table )
  980. {
  981.    GET_CONTEXT;
  982.    CHECK_CONTEXT;
  983.    (*CC->API.GetColorTable)(CC, target, format, type, table);
  984. }
  985.  
  986.  
  987. void APIENTRY glGetColorTableParameterivEXT( GLenum target, GLenum pname,
  988.                          GLint *params )
  989. {
  990.    GET_CONTEXT;
  991.    CHECK_CONTEXT;
  992.    (*CC->API.GetColorTableParameteriv)(CC, target, pname, params);
  993. }
  994.  
  995.  
  996. void APIENTRY glGetColorTableParameterfvEXT( GLenum target, GLenum pname,
  997.                          GLfloat *params )
  998. {
  999.    GLint iparams;
  1000.    glGetColorTableParameterivEXT( target, pname, &iparams );
  1001.    *params = (GLfloat) iparams;
  1002. }
  1003.  
  1004.  
  1005. void APIENTRY glGetDoublev( GLenum pname, GLdouble *params )
  1006. {
  1007.    GET_CONTEXT;
  1008.    CHECK_CONTEXT;
  1009.    (*CC->API.GetDoublev)(CC, pname, params);
  1010. }
  1011.  
  1012.  
  1013. GLenum APIENTRY glGetError( void )
  1014. {
  1015.    GET_CONTEXT;
  1016.    if (!CC) {
  1017.       /* No current context */
  1018.       return GL_NO_ERROR;
  1019.    }
  1020.    return (*CC->API.GetError)(CC);
  1021. }
  1022.  
  1023.  
  1024. void APIENTRY glGetFloatv( GLenum pname, GLfloat *params )
  1025. {
  1026.    GET_CONTEXT;
  1027.    CHECK_CONTEXT;
  1028.    (*CC->API.GetFloatv)(CC, pname, params);
  1029. }
  1030.  
  1031.  
  1032. void APIENTRY glGetIntegerv( GLenum pname, GLint *params )
  1033. {
  1034.    GET_CONTEXT;
  1035.    CHECK_CONTEXT;
  1036.    (*CC->API.GetIntegerv)(CC, pname, params);
  1037. }
  1038.  
  1039.  
  1040. void APIENTRY glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
  1041. {
  1042.    GET_CONTEXT;
  1043.    CHECK_CONTEXT;
  1044.    (*CC->API.GetLightfv)(CC, light, pname, params);
  1045. }
  1046.  
  1047.  
  1048. void APIENTRY glGetLightiv( GLenum light, GLenum pname, GLint *params )
  1049. {
  1050.    GET_CONTEXT;
  1051.    CHECK_CONTEXT;
  1052.    (*CC->API.GetLightiv)(CC, light, pname, params);
  1053. }
  1054.  
  1055.  
  1056. void APIENTRY glGetMapdv( GLenum target, GLenum query, GLdouble *v )
  1057. {
  1058.    GET_CONTEXT;
  1059.    CHECK_CONTEXT;
  1060.    (*CC->API.GetMapdv)( CC, target, query, v );
  1061. }
  1062.  
  1063.  
  1064. void APIENTRY glGetMapfv( GLenum target, GLenum query, GLfloat *v )
  1065. {
  1066.    GET_CONTEXT;
  1067.    CHECK_CONTEXT;
  1068.    (*CC->API.GetMapfv)( CC, target, query, v );
  1069. }
  1070.  
  1071.  
  1072. void APIENTRY glGetMapiv( GLenum target, GLenum query, GLint *v )
  1073. {
  1074.    GET_CONTEXT;
  1075.    CHECK_CONTEXT;
  1076.    (*CC->API.GetMapiv)( CC, target, query, v );
  1077. }
  1078.  
  1079.  
  1080. void APIENTRY glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
  1081. {
  1082.    GET_CONTEXT;
  1083.    CHECK_CONTEXT;
  1084.    (*CC->API.GetMaterialfv)(CC, face, pname, params);
  1085. }
  1086.  
  1087.  
  1088. void APIENTRY glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
  1089. {
  1090.    GET_CONTEXT;
  1091.    CHECK_CONTEXT;
  1092.    (*CC->API.GetMaterialiv)(CC, face, pname, params);
  1093. }
  1094.  
  1095.  
  1096. void APIENTRY glGetPixelMapfv( GLenum map, GLfloat *values )
  1097. {
  1098.    GET_CONTEXT;
  1099.    CHECK_CONTEXT;
  1100.    (*CC->API.GetPixelMapfv)(CC, map, values);
  1101. }
  1102.  
  1103.  
  1104. void APIENTRY glGetPixelMapuiv( GLenum map, GLuint *values )
  1105. {
  1106.    GET_CONTEXT;
  1107.    CHECK_CONTEXT;
  1108.    (*CC->API.GetPixelMapuiv)(CC, map, values);
  1109. }
  1110.  
  1111.  
  1112. void APIENTRY glGetPixelMapusv( GLenum map, GLushort *values )
  1113. {
  1114.    GET_CONTEXT;
  1115.    CHECK_CONTEXT;
  1116.    (*CC->API.GetPixelMapusv)(CC, map, values);
  1117. }
  1118.  
  1119.  
  1120. void APIENTRY glGetPointerv( GLenum pname, GLvoid **params )
  1121. {
  1122.    GET_CONTEXT;
  1123.    CHECK_CONTEXT;
  1124.    (*CC->API.GetPointerv)(CC, pname, params);
  1125. }
  1126.  
  1127.  
  1128. void APIENTRY glGetPolygonStipple( GLubyte *mask )
  1129. {
  1130.    GET_CONTEXT;
  1131.    CHECK_CONTEXT;
  1132.    (*CC->API.GetPolygonStipple)(CC, mask);
  1133. }
  1134.  
  1135.  
  1136. const GLubyte * APIENTRY glGetString( GLenum name )
  1137. {
  1138.    GET_CONTEXT;
  1139.    CHECK_CONTEXT_RETURN(NULL);
  1140.    return (*CC->API.GetString)(CC, name);
  1141. }
  1142.  
  1143.  
  1144.  
  1145. void APIENTRY glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
  1146. {
  1147.    GET_CONTEXT;
  1148.    CHECK_CONTEXT;
  1149.    (*CC->API.GetTexEnvfv)(CC, target, pname, params);
  1150. }
  1151.  
  1152.  
  1153. void APIENTRY glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
  1154. {
  1155.    GET_CONTEXT;
  1156.    CHECK_CONTEXT;
  1157.    (*CC->API.GetTexEnviv)(CC, target, pname, params);
  1158. }
  1159.  
  1160.  
  1161. void APIENTRY glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
  1162. {
  1163.    GET_CONTEXT;
  1164.    CHECK_CONTEXT;
  1165.    (*CC->API.GetTexGeniv)(CC, coord, pname, params);
  1166. }
  1167.  
  1168.  
  1169. void APIENTRY glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
  1170. {
  1171.    GET_CONTEXT;
  1172.    CHECK_CONTEXT;
  1173.    (*CC->API.GetTexGendv)(CC, coord, pname, params);
  1174. }
  1175.  
  1176.  
  1177. void APIENTRY glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
  1178. {
  1179.    GET_CONTEXT;
  1180.    CHECK_CONTEXT;
  1181.    (*CC->API.GetTexGenfv)(CC, coord, pname, params);
  1182. }
  1183.  
  1184.  
  1185.  
  1186. void APIENTRY glGetTexImage( GLenum target, GLint level, GLenum format,
  1187.                  GLenum type, GLvoid *pixels )
  1188. {
  1189.    GET_CONTEXT;
  1190.    CHECK_CONTEXT;
  1191.    (*CC->API.GetTexImage)(CC, target, level, format, type, pixels);
  1192. }
  1193.  
  1194.  
  1195. void APIENTRY glGetTexLevelParameterfv( GLenum target, GLint level,
  1196.                     GLenum pname, GLfloat *params )
  1197. {
  1198.    GET_CONTEXT;
  1199.    CHECK_CONTEXT;
  1200.    (*CC->API.GetTexLevelParameterfv)(CC, target, level, pname, params);
  1201. }
  1202.  
  1203.  
  1204. void APIENTRY glGetTexLevelParameteriv( GLenum target, GLint level,
  1205.                     GLenum pname, GLint *params )
  1206. {
  1207.    GET_CONTEXT;
  1208.    CHECK_CONTEXT;
  1209.    (*CC->API.GetTexLevelParameteriv)(CC, target, level, pname, params);
  1210. }
  1211.  
  1212.  
  1213.  
  1214.  
  1215. void APIENTRY glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params)
  1216. {
  1217.    GET_CONTEXT;
  1218.    CHECK_CONTEXT;
  1219.    (*CC->API.GetTexParameterfv)(CC, target, pname, params);
  1220. }
  1221.  
  1222.  
  1223. void APIENTRY glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
  1224. {
  1225.    GET_CONTEXT;
  1226.    CHECK_CONTEXT;
  1227.    (*CC->API.GetTexParameteriv)(CC, target, pname, params);
  1228. }
  1229.  
  1230.  
  1231. void APIENTRY glHint( GLenum target, GLenum mode )
  1232. {
  1233.    GET_CONTEXT;
  1234.    CHECK_CONTEXT;
  1235.    (*CC->API.Hint)(CC, target, mode);
  1236. }
  1237.  
  1238.  
  1239. void APIENTRY glIndexd( GLdouble c )
  1240. {
  1241.    GET_CONTEXT;
  1242.    (*CC->API.Indexf)( CC, (GLfloat) c );
  1243. }
  1244.  
  1245.  
  1246. void APIENTRY glIndexf( GLfloat c )
  1247. {
  1248.    GET_CONTEXT;
  1249.    (*CC->API.Indexf)( CC, c );
  1250. }
  1251.  
  1252.  
  1253. void APIENTRY glIndexi( GLint c )
  1254. {
  1255.    GET_CONTEXT;
  1256.    (*CC->API.Indexi)( CC, c );
  1257. }
  1258.  
  1259.  
  1260. void APIENTRY glIndexs( GLshort c )
  1261. {
  1262.    GET_CONTEXT;
  1263.    (*CC->API.Indexi)( CC, (GLint) c );
  1264. }
  1265.  
  1266.  
  1267. #ifdef GL_VERSION_1_1
  1268. void APIENTRY glIndexub( GLubyte c )
  1269. {
  1270.    GET_CONTEXT;
  1271.    (*CC->API.Indexi)( CC, (GLint) c );
  1272. }
  1273. #endif
  1274.  
  1275.  
  1276. void APIENTRY glIndexdv( const GLdouble *c )
  1277. {
  1278.    GET_CONTEXT;
  1279.    (*CC->API.Indexf)( CC, (GLfloat) *c );
  1280. }
  1281.  
  1282.  
  1283. void APIENTRY glIndexfv( const GLfloat *c )
  1284. {
  1285.    GET_CONTEXT;
  1286.    (*CC->API.Indexf)( CC, *c );
  1287. }
  1288.  
  1289.  
  1290. void APIENTRY glIndexiv( const GLint *c )
  1291. {
  1292.    GET_CONTEXT;
  1293.    (*CC->API.Indexi)( CC, *c );
  1294. }
  1295.  
  1296.  
  1297. void APIENTRY glIndexsv( const GLshort *c )
  1298. {
  1299.    GET_CONTEXT;
  1300.    (*CC->API.Indexi)( CC, (GLint) *c );
  1301. }
  1302.  
  1303.  
  1304. #ifdef GL_VERSION_1_1
  1305. void APIENTRY glIndexubv( const GLubyte *c )
  1306. {
  1307.    GET_CONTEXT;
  1308.    (*CC->API.Indexi)( CC, (GLint) *c );
  1309. }
  1310. #endif
  1311.  
  1312.  
  1313. void APIENTRY glIndexMask( GLuint mask )
  1314. {
  1315.    GET_CONTEXT;
  1316.    (*CC->API.IndexMask)(CC, mask);
  1317. }
  1318.  
  1319.  
  1320. void APIENTRY glIndexPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
  1321. {
  1322.    GET_CONTEXT;
  1323.    CHECK_CONTEXT;
  1324.    (*CC->API.IndexPointer)(CC, type, stride, ptr);
  1325. }
  1326.  
  1327.  
  1328. void APIENTRY glInterleavedArrays( GLenum format, GLsizei stride,
  1329.                    const GLvoid *pointer )
  1330. {
  1331.    GET_CONTEXT;
  1332.    CHECK_CONTEXT;
  1333.    (*CC->API.InterleavedArrays)( CC, format, stride, pointer );
  1334. }
  1335.  
  1336.  
  1337. void APIENTRY glInitNames( void )
  1338. {
  1339.    GET_CONTEXT;
  1340.    CHECK_CONTEXT;
  1341.    (*CC->API.InitNames)(CC);
  1342. }
  1343.  
  1344.  
  1345. GLboolean APIENTRY glIsList( GLuint list )
  1346. {
  1347.    GET_CONTEXT;
  1348.    CHECK_CONTEXT_RETURN(GL_FALSE);
  1349.    return (*CC->API.IsList)(CC, list);
  1350. }
  1351.  
  1352.  
  1353. GLboolean APIENTRY glIsTexture( GLuint texture )
  1354. {
  1355.    GET_CONTEXT;
  1356.    CHECK_CONTEXT_RETURN(GL_FALSE);
  1357.    return (*CC->API.IsTexture)(CC, texture);
  1358. }
  1359.  
  1360.  
  1361. void APIENTRY glLightf( GLenum light, GLenum pname, GLfloat param )
  1362. {
  1363.    GET_CONTEXT;
  1364.    CHECK_CONTEXT;
  1365.    (*CC->API.Lightfv)( CC, light, pname, ¶m, 1 );
  1366. }
  1367.  
  1368.  
  1369.  
  1370. void APIENTRY glLighti( GLenum light, GLenum pname, GLint param )
  1371. {
  1372.    GLfloat fparam = (GLfloat) param;
  1373.    GET_CONTEXT;
  1374.    CHECK_CONTEXT;
  1375.    (*CC->API.Lightfv)( CC, light, pname, &fparam, 1 );
  1376. }
  1377.  
  1378.  
  1379.  
  1380. void APIENTRY glLightfv( GLenum light, GLenum pname, const GLfloat *params )
  1381. {
  1382.    GET_CONTEXT;
  1383.    CHECK_CONTEXT;
  1384.    (*CC->API.Lightfv)( CC, light, pname, params, 4 );
  1385. }
  1386.  
  1387.  
  1388.  
  1389. void APIENTRY glLightiv( GLenum light, GLenum pname, const GLint *params )
  1390. {
  1391.    GLfloat fparam[4];
  1392.    GET_CONTEXT;
  1393.    CHECK_CONTEXT;
  1394.  
  1395.    switch (pname) {
  1396.       case GL_AMBIENT:
  1397.       case GL_DIFFUSE:
  1398.       case GL_SPECULAR:
  1399.      fparam[0] = INT_TO_FLOAT( params[0] );
  1400.      fparam[1] = INT_TO_FLOAT( params[1] );
  1401.      fparam[2] = INT_TO_FLOAT( params[2] );
  1402.      fparam[3] = INT_TO_FLOAT( params[3] );
  1403.      break;
  1404.       case GL_POSITION:
  1405.      fparam[0] = (GLfloat) params[0];
  1406.      fparam[1] = (GLfloat) params[1];
  1407.      fparam[2] = (GLfloat) params[2];
  1408.      fparam[3] = (GLfloat) params[3];
  1409.      break;
  1410.       case GL_SPOT_DIRECTION:
  1411.      fparam[0] = (GLfloat) params[0];
  1412.      fparam[1] = (GLfloat) params[1];
  1413.      fparam[2] = (GLfloat) params[2];
  1414.      break;
  1415.       case GL_SPOT_EXPONENT:
  1416.       case GL_SPOT_CUTOFF:
  1417.       case GL_CONSTANT_ATTENUATION:
  1418.       case GL_LINEAR_ATTENUATION:
  1419.       case GL_QUADRATIC_ATTENUATION:
  1420.      fparam[0] = (GLfloat) params[0];
  1421.      break;
  1422.       default:
  1423.          /* error will be caught later in gl_Lightfv */
  1424.          ;
  1425.    }
  1426.    (*CC->API.Lightfv)( CC, light, pname, fparam, 4 );
  1427. }
  1428.  
  1429.  
  1430.  
  1431. void APIENTRY glLightModelf( GLenum pname, GLfloat param )
  1432. {
  1433.    GET_CONTEXT;
  1434.    CHECK_CONTEXT;
  1435.    (*CC->API.LightModelfv)( CC, pname, ¶m );
  1436. }
  1437.  
  1438.  
  1439. void APIENTRY glLightModeli( GLenum pname, GLint param )
  1440. {
  1441.    GLfloat fparam[4];
  1442.    GET_CONTEXT;
  1443.    CHECK_CONTEXT;
  1444.    fparam[0] = (GLfloat) param;
  1445.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1446. }
  1447.  
  1448.  
  1449. void APIENTRY glLightModelfv( GLenum pname, const GLfloat *params )
  1450. {
  1451.    GET_CONTEXT;
  1452.    CHECK_CONTEXT;
  1453.    (*CC->API.LightModelfv)( CC, pname, params );
  1454. }
  1455.  
  1456.  
  1457. void APIENTRY glLightModeliv( GLenum pname, const GLint *params )
  1458. {
  1459.    GLfloat fparam[4];
  1460.    GET_CONTEXT;
  1461.    CHECK_CONTEXT;
  1462.  
  1463.    switch (pname) {
  1464.       case GL_LIGHT_MODEL_AMBIENT:
  1465.      fparam[0] = INT_TO_FLOAT( params[0] );
  1466.      fparam[1] = INT_TO_FLOAT( params[1] );
  1467.      fparam[2] = INT_TO_FLOAT( params[2] );
  1468.      fparam[3] = INT_TO_FLOAT( params[3] );
  1469.      break;
  1470.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1471.       case GL_LIGHT_MODEL_TWO_SIDE:
  1472.      fparam[0] = (GLfloat) params[0];
  1473.      break;
  1474.       default:
  1475.      /* Error will be caught later in gl_LightModelfv */
  1476.      ;
  1477.    }
  1478.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1479. }
  1480.  
  1481.  
  1482. void APIENTRY glLineWidth( GLfloat width )
  1483. {
  1484.    GET_CONTEXT;
  1485.    CHECK_CONTEXT;
  1486.    (*CC->API.LineWidth)(CC, width);
  1487. }
  1488.  
  1489.  
  1490. void APIENTRY glLineStipple( GLint factor, GLushort pattern )
  1491. {
  1492.    GET_CONTEXT;
  1493.    CHECK_CONTEXT;
  1494.    (*CC->API.LineStipple)(CC, factor, pattern);
  1495. }
  1496.  
  1497.  
  1498. void APIENTRY glListBase( GLuint base )
  1499. {
  1500.    GET_CONTEXT;
  1501.    CHECK_CONTEXT;
  1502.    (*CC->API.ListBase)(CC, base);
  1503. }
  1504.  
  1505.  
  1506. void APIENTRY glLoadIdentity( void )
  1507. {
  1508.    GET_CONTEXT;
  1509.    CHECK_CONTEXT;
  1510.    (*CC->API.LoadIdentity)( CC );
  1511. }
  1512.  
  1513.  
  1514. void APIENTRY glLoadMatrixd( const GLdouble *m )
  1515. {
  1516.    GLfloat fm[16];
  1517.    GLuint i;
  1518.    GET_CONTEXT;
  1519.    CHECK_CONTEXT;
  1520.  
  1521.    for (i=0;i<16;i++) {
  1522.       fm[i] = (GLfloat) m[i];
  1523.    }
  1524.  
  1525.    (*CC->API.LoadMatrixf)( CC, fm );
  1526. }
  1527.  
  1528.  
  1529. void APIENTRY glLoadMatrixf( const GLfloat *m )
  1530. {
  1531.    GET_CONTEXT;
  1532.    CHECK_CONTEXT;
  1533.    (*CC->API.LoadMatrixf)( CC, m );
  1534. }
  1535.  
  1536.  
  1537. void APIENTRY glLoadName( GLuint name )
  1538. {
  1539.    GET_CONTEXT;
  1540.    CHECK_CONTEXT;
  1541.    (*CC->API.LoadName)(CC, name);
  1542. }
  1543.  
  1544.  
  1545. void APIENTRY glLogicOp( GLenum opcode )
  1546. {
  1547.    GET_CONTEXT;
  1548.    CHECK_CONTEXT;
  1549.    (*CC->API.LogicOp)(CC, opcode);
  1550. }
  1551.  
  1552.  
  1553.  
  1554. void APIENTRY glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
  1555.                GLint order, const GLdouble *points )
  1556. {
  1557.    GLfloat *pnts;
  1558.    GLboolean retain;
  1559.    GET_CONTEXT;
  1560.    CHECK_CONTEXT;
  1561.  
  1562.    pnts = gl_copy_map_points1d( target, stride, order, points );
  1563.    retain = CC->CompileFlag;
  1564.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1565. }
  1566.  
  1567.  
  1568. void APIENTRY glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
  1569.                GLint order, const GLfloat *points )
  1570. {
  1571.    GLfloat *pnts;
  1572.    GLboolean retain;
  1573.  
  1574.    GET_CONTEXT;
  1575.    CHECK_CONTEXT;
  1576.  
  1577.    pnts = gl_copy_map_points1f( target, stride, order, points );
  1578.    retain = CC->CompileFlag;
  1579.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1580. }
  1581.  
  1582.  
  1583. void APIENTRY glMap2d( GLenum target,
  1584.                GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
  1585.                GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
  1586.                const GLdouble *points )
  1587. {
  1588.    GLfloat *pnts;
  1589.    GLboolean retain;
  1590.    GET_CONTEXT;
  1591.    CHECK_CONTEXT;
  1592.  
  1593.    pnts = gl_copy_map_points2d( target, ustride, uorder,
  1594.                 vstride, vorder, points );
  1595.    retain = CC->CompileFlag;
  1596.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1597.              v1, v2, vstride, vorder, pnts, retain );
  1598. }
  1599.  
  1600.  
  1601. void APIENTRY glMap2f( GLenum target,
  1602.                GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  1603.                GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  1604.                const GLfloat *points )
  1605. {
  1606.    GLfloat *pnts;
  1607.    GLboolean retain;
  1608.    GET_CONTEXT;
  1609.    CHECK_CONTEXT;
  1610.  
  1611.    pnts = gl_copy_map_points2f( target, ustride, uorder,
  1612.                 vstride, vorder, points );
  1613.    retain = CC->CompileFlag;
  1614.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1615.              v1, v2, vstride, vorder, pnts, retain );
  1616. }
  1617.  
  1618.  
  1619. void APIENTRY glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
  1620. {
  1621.    GET_CONTEXT;
  1622.    CHECK_CONTEXT;
  1623.    (*CC->API.MapGrid1f)( CC, un, (GLfloat) u1, (GLfloat) u2 );
  1624. }
  1625.  
  1626.  
  1627. void APIENTRY glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
  1628. {
  1629.    GET_CONTEXT;
  1630.    CHECK_CONTEXT;
  1631.    (*CC->API.MapGrid1f)( CC, un, u1, u2 );
  1632. }
  1633.  
  1634.  
  1635. void APIENTRY glMapGrid2d( GLint un, GLdouble u1, GLdouble u2,
  1636.                GLint vn, GLdouble v1, GLdouble v2 )
  1637. {
  1638.    GET_CONTEXT;
  1639.    CHECK_CONTEXT;
  1640.    (*CC->API.MapGrid2f)( CC, un, (GLfloat) u1, (GLfloat) u2,
  1641.              vn, (GLfloat) v1, (GLfloat) v2 );
  1642. }
  1643.  
  1644.  
  1645. void APIENTRY glMapGrid2f( GLint un, GLfloat u1, GLfloat u2,
  1646.                GLint vn, GLfloat v1, GLfloat v2 )
  1647. {
  1648.    GET_CONTEXT;
  1649.    CHECK_CONTEXT;
  1650.    (*CC->API.MapGrid2f)( CC, un, u1, u2, vn, v1, v2 );
  1651. }
  1652.  
  1653.  
  1654. void APIENTRY glMaterialf( GLenum face, GLenum pname, GLfloat param )
  1655. {
  1656.    GET_CONTEXT;
  1657.    CHECK_CONTEXT;
  1658.    (*CC->API.Materialfv)( CC, face, pname, ¶m );
  1659. }
  1660.  
  1661.  
  1662.  
  1663. void APIENTRY glMateriali( GLenum face, GLenum pname, GLint param )
  1664. {
  1665.    GLfloat fparam[4];
  1666.    GET_CONTEXT;
  1667.    CHECK_CONTEXT;
  1668.    fparam[0] = (GLfloat) param;
  1669.    (*CC->API.Materialfv)( CC, face, pname, fparam );
  1670. }
  1671.  
  1672.  
  1673. void APIENTRY glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
  1674. {
  1675.    GET_CONTEXT;
  1676.    CHECK_CONTEXT;
  1677.    (*CC->API.Materialfv)( CC, face, pname, params );
  1678. }
  1679.  
  1680.  
  1681. void APIENTRY glMaterialiv( GLenum face, GLenum pname, const GLint *params )
  1682. {
  1683.    GLfloat fparam[4];
  1684.    GET_CONTEXT;
  1685.    CHECK_CONTEXT;
  1686.    switch (pname) {
  1687.       case GL_AMBIENT:
  1688.       case GL_DIFFUSE:
  1689.       case GL_SPECULAR:
  1690.       case GL_EMISSION:
  1691.       case GL_AMBIENT_AND_DIFFUSE:
  1692.      fparam[0] = INT_TO_FLOAT( params[0] );
  1693.      fparam[1] = INT_TO_FLOAT( params[1] );
  1694.      fparam[2] = INT_TO_FLOAT( params[2] );
  1695.      fparam[3] = INT_TO_FLOAT( params[3] );
  1696.      break;
  1697.       case GL_SHININESS:
  1698.      fparam[0] = (GLfloat) params[0];
  1699.      break;
  1700.       case GL_COLOR_INDEXES:
  1701.      fparam[0] = (GLfloat) params[0];
  1702.      fparam[1] = (GLfloat) params[1];
  1703.      fparam[2] = (GLfloat) params[2];
  1704.      break;
  1705.       default:
  1706.      /* Error will be caught later in gl_Materialfv */
  1707.      ;
  1708.    }
  1709.    (*CC->API.Materialfv)( CC, face, pname, fparam );
  1710. }
  1711.  
  1712.  
  1713. void APIENTRY glMatrixMode( GLenum mode )
  1714. {
  1715.    GET_CONTEXT;
  1716.    CHECK_CONTEXT;
  1717.    (*CC->API.MatrixMode)( CC, mode );
  1718. }
  1719.  
  1720.  
  1721. void APIENTRY glMultMatrixd( const GLdouble *m )
  1722. {
  1723.    GLfloat fm[16];
  1724.    GLuint i;
  1725.    GET_CONTEXT;
  1726.    CHECK_CONTEXT;
  1727.  
  1728.    for (i=0;i<16;i++) {
  1729.       fm[i] = (GLfloat) m[i];
  1730.    }
  1731.  
  1732.    (*CC->API.MultMatrixf)( CC, fm );
  1733. }
  1734.  
  1735.  
  1736. void APIENTRY glMultMatrixf( const GLfloat *m )
  1737. {
  1738.    GET_CONTEXT;
  1739.    CHECK_CONTEXT;
  1740.    (*CC->API.MultMatrixf)( CC, m );
  1741. }
  1742.  
  1743.  
  1744. void APIENTRY glNewList( GLuint list, GLenum mode )
  1745. {
  1746.    GET_CONTEXT;
  1747.    CHECK_CONTEXT;
  1748.    (*CC->API.NewList)(CC, list, mode);
  1749. }
  1750.  
  1751. void APIENTRY glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
  1752. {
  1753.    GET_CONTEXT;
  1754.    (*CC->API.Normal3f)( CC, BYTE_TO_FLOAT(nx),
  1755.             BYTE_TO_FLOAT(ny), BYTE_TO_FLOAT(nz) );
  1756. }
  1757.  
  1758.  
  1759. void APIENTRY glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
  1760. {
  1761.    GLfloat fx, fy, fz;
  1762.    GET_CONTEXT;
  1763.    if (ABSD(nx)<0.00001)   fx = 0.0F;   else  fx = nx;
  1764.    if (ABSD(ny)<0.00001)   fy = 0.0F;   else  fy = ny;
  1765.    if (ABSD(nz)<0.00001)   fz = 0.0F;   else  fz = nz;
  1766.    (*CC->API.Normal3f)( CC, fx, fy, fz );
  1767. }
  1768.  
  1769.  
  1770. void APIENTRY glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
  1771. {
  1772.    GET_CONTEXT;
  1773. #ifdef SHORTCUT
  1774.    if (CC->CompileFlag) {
  1775.       (*CC->Save.Normal3f)( CC, nx, ny, nz );
  1776.    }
  1777.    else {
  1778.       /* Execute */
  1779.       CC->Current.Normal[0] = nx;
  1780.       CC->Current.Normal[1] = ny;
  1781.       CC->Current.Normal[2] = nz;
  1782.       CC->VB->MonoNormal = GL_FALSE;
  1783.    }
  1784. #else
  1785.    (*CC->API.Normal3f)( CC, nx, ny, nz );
  1786. #endif
  1787. }
  1788.  
  1789.  
  1790. void APIENTRY glNormal3i( GLint nx, GLint ny, GLint nz )
  1791. {
  1792.    GET_CONTEXT;
  1793.    (*CC->API.Normal3f)( CC, INT_TO_FLOAT(nx),
  1794.             INT_TO_FLOAT(ny), INT_TO_FLOAT(nz) );
  1795. }
  1796.  
  1797.  
  1798. void APIENTRY glNormal3s( GLshort nx, GLshort ny, GLshort nz )
  1799. {
  1800.    GET_CONTEXT;
  1801.    (*CC->API.Normal3f)( CC, SHORT_TO_FLOAT(nx),
  1802.             SHORT_TO_FLOAT(ny), SHORT_TO_FLOAT(nz) );
  1803. }
  1804.  
  1805.  
  1806. void APIENTRY glNormal3bv( const GLbyte *v )
  1807. {
  1808.    GET_CONTEXT;
  1809.    (*CC->API.Normal3f)( CC, BYTE_TO_FLOAT(v[0]),
  1810.             BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]) );
  1811. }
  1812.  
  1813.  
  1814. void APIENTRY glNormal3dv( const GLdouble *v )
  1815. {
  1816.    GLfloat fx, fy, fz;
  1817.    GET_CONTEXT;
  1818.    if (ABSD(v[0])<0.00001)   fx = 0.0F;   else  fx = v[0];
  1819.    if (ABSD(v[1])<0.00001)   fy = 0.0F;   else  fy = v[1];
  1820.    if (ABSD(v[2])<0.00001)   fz = 0.0F;   else  fz = v[2];
  1821.    (*CC->API.Normal3f)( CC, fx, fy, fz );
  1822. }
  1823.  
  1824.  
  1825. void APIENTRY glNormal3fv( const GLfloat *v )
  1826. {
  1827.    GET_CONTEXT;
  1828. #ifdef SHORTCUT
  1829.    if (CC->CompileFlag) {
  1830.       (*CC->Save.Normal3fv)( CC, v );
  1831.    }
  1832.    else {
  1833.       /* Execute */
  1834.       GLfloat *n = CC->Current.Normal;
  1835.       n[0] = v[0];
  1836.       n[1] = v[1];
  1837.       n[2] = v[2];
  1838.       CC->VB->MonoNormal = GL_FALSE;
  1839.    }
  1840. #else
  1841.    (*CC->API.Normal3fv)( CC, v );
  1842. #endif
  1843. }
  1844.  
  1845.  
  1846. void APIENTRY glNormal3iv( const GLint *v )
  1847. {
  1848.    GET_CONTEXT;
  1849.    (*CC->API.Normal3f)( CC, INT_TO_FLOAT(v[0]),
  1850.             INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]) );
  1851. }
  1852.  
  1853.  
  1854. void APIENTRY glNormal3sv( const GLshort *v )
  1855. {
  1856.    GET_CONTEXT;
  1857.    (*CC->API.Normal3f)( CC, SHORT_TO_FLOAT(v[0]),
  1858.             SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]) );
  1859. }
  1860.  
  1861.  
  1862. void APIENTRY glNormalPointer( GLenum type, GLsizei stride, const GLvoid *ptr )
  1863. {
  1864.    GET_CONTEXT;
  1865.    CHECK_CONTEXT;
  1866.    (*CC->API.NormalPointer)(CC, type, stride, ptr);
  1867. }
  1868.  
  1869.