home *** CD-ROM | disk | FTP | other *** search
/ Dream 57 / Amiga_Dream_57.iso / Amiga / Programmation / c / Exemples / Affichage / CyberGL-DevKit.lha / lib / libgl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-05-13  |  60.7 KB  |  1,981 lines
  1. #ifndef _LIB_CYBERGL_H
  2. #define _LIB_CYBERGL_H
  3.  
  4. #ifndef __INLINE_MACROS_H
  5. #include <inline/macros.h>
  6. #endif /* !__INLINE_MACROS_H */
  7.  
  8. #ifndef CYBERGL_BASE_NAME
  9. #define CYBERGL_BASE_NAME CyberGLBase
  10. #endif /* !CYBERGL_BASE_NAME */
  11.  
  12. #include <inline/exec.h>
  13. #include <gl/gl.h>
  14.  
  15. /* externs from crt0.c */
  16. extern void *ixemulbase;
  17. extern int errno;
  18. extern char *_ctype_;
  19. extern void *__sF;
  20. extern void *__stk_limit;
  21.  
  22. extern struct ExecBase *SysBase;
  23. struct Library *CyberGLBase = 0;
  24.  
  25. void constructor(void) {
  26.   if(!(CyberGLBase = OpenLibrary("cybergl.library", 39))) {
  27.     printf("Can't open CyberGL.library version 39!\n");
  28.     exit(10);
  29.   }
  30. }
  31.  
  32. void destructor(void) {
  33.   if(CyberGLBase) {
  34.     CloseLibrary(CyberGLBase);
  35.     CyberGLBase = 0;
  36.   }
  37. }
  38.  
  39. asm ("    .text;     .stabs \"___CTOR_LIST__\",22,0,0,_constructor");
  40. asm ("    .text;     .stabs \"___DTOR_LIST__\",22,0,0,_destructor");
  41.  
  42. #define allocColor_jump(window, r, g, b) \
  43.     LP4(0x42, GLubyte, allocColor, GLvoid *, window, a0, GLubyte, r, d0, GLubyte, g, d1, GLubyte, b, d2, \
  44.     , CYBERGL_BASE_NAME)
  45. GLubyte allocColor(GLvoid *window, GLubyte r, GLubyte g, GLubyte b) {
  46.   return allocColor_jump(window, r, g, b);
  47. }
  48.  
  49. #define allocColorRange_jump(window, r1, g1, b1, r2, g2, b2, num) \
  50.     LP8(0x48, GLubyte, allocColorRange, GLvoid *, window, a0, GLubyte, r1, d0, GLubyte, g1, d1, GLubyte, b1, d2, GLubyte, r2, d3, GLubyte, g2, d4, GLubyte, b2, d5, GLubyte, num, d6, \
  51.     , CYBERGL_BASE_NAME)
  52. GLubyte allocColorRange(GLvoid *window, GLubyte r1, GLubyte g1, GLubyte b1, GLubyte r2, GLubyte g2, GLubyte b2, GLubyte num) {
  53.   return allocColorRange_jump(window, r1, g1, b1, r2, g2, b2, num);
  54. }
  55.  
  56. #define attachGLWindowTagList_jump(wnd, width, height, tags) \
  57.     LP4(0x2a, GLvoid *, attachGLWindowTagList, struct Window *, wnd, a0, GLint, width, d0, GLint, height, d1, struct TagItem *, tags, a1, \
  58.     , CYBERGL_BASE_NAME)
  59. GLvoid *attachGLWindowTagList(struct Window *wnd, GLint width, GLint height, struct TagItem *tags) {
  60.   return attachGLWindowTagList_jump(wnd, width, height, tags);
  61. }
  62.  
  63. #ifndef NO_INLINE_STDARG
  64. #define attachGLWindowTags(a0, a1, a2, tags...) \
  65.     ({ULONG _tags[] = { tags }; attachGLWindowTagList((a0), (a1), (a2), (struct TagItem *)_tags);})
  66. #endif /* !NO_INLINE_STDARG */
  67.  
  68. #define attachGLWndToRPTagList_jump(scr, rp, width, height, tags) \
  69.     LP5(0x4e, GLvoid *, attachGLWndToRPTagList, struct Screen *, scr, a0, struct RastPort *, rp, a1, GLint, width, d0, GLint, height, d1, struct TagItem *, tags, a2, \
  70.     , CYBERGL_BASE_NAME)
  71. GLvoid *attachGLWndToRPTagList(struct Screen *scr, struct RastPort *rp, GLint width, GLint height, struct TagItem *tags) {
  72.   return attachGLWndToRPTagList_jump(scr, rp, width, height, tags);
  73. }
  74.  
  75. #ifndef NO_INLINE_STDARG
  76. #define attachGLWndToRPTags(a0, a1, a2, a3, tags...) \
  77.     ({ULONG _tags[] = { tags }; attachGLWndToRPTagList((a0), (a1), (a2), (a3), (struct TagItem *)_tags);})
  78. #endif /* !NO_INLINE_STDARG */
  79.  
  80. #define closeGLWindow_jump(window) \
  81.     LP1NR(0x24, closeGLWindow, GLvoid *, window, a0, \
  82.     , CYBERGL_BASE_NAME)
  83. GLvoid closeGLWindow(GLvoid *window) {
  84.   closeGLWindow_jump(window);
  85. }
  86.  
  87. #define disposeGLWindow_jump(window) \
  88.     LP1NR(0x30, disposeGLWindow, GLvoid *, window, a0, \
  89.     , CYBERGL_BASE_NAME)
  90. GLvoid disposeGLWindow(GLvoid *window) {
  91.   disposeGLWindow_jump(window);
  92. }
  93.  
  94. #define getWindow_jump(window) \
  95.     LP1(0x3c, struct Window *, getWindow, GLvoid *, window, a0, \
  96.     , CYBERGL_BASE_NAME)
  97. struct Window *getWindow(GLvoid *window) {
  98.   return getWindow_jump(window);
  99. }
  100.  
  101. #define glBegin_jump(mode) \
  102.     LP1NR(0x114, glBegin, GLenum, mode, d0, \
  103.     , CYBERGL_BASE_NAME)
  104. GLvoid glBegin(GLenum mode) {
  105.   glBegin_jump(mode);
  106. }
  107.  
  108. #define glBitmap_jump(bitmap) \
  109.     LP1NR(0x66c, glBitmap, const GLbitmap *, bitmap, a0, \
  110.     , CYBERGL_BASE_NAME)
  111. GLvoid glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig,
  112.                 GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) {
  113.   GLbitmap sbitmap;
  114.   
  115.   sbitmap.width = width;
  116.   sbitmap.height = height;
  117.   sbitmap.xorig = xorig;
  118.   sbitmap.xmove = xmove;
  119.   sbitmap.ymove = ymove;
  120.   sbitmap.bitmap = bitmap;
  121.   
  122.   glBitmap_jump(&sbitmap);
  123. }
  124.  
  125. #define glClear_jump(mask) \
  126.     LP1NR(0x4fe, glClear, GLbitfield, mask, d0, \
  127.     , CYBERGL_BASE_NAME)
  128. GLvoid glClear(GLbitfield mask) {
  129.   glClear_jump(mask);
  130. }
  131.  
  132. #define glClearColor_jump(red, green, blue, alpha) \
  133.     LP4NR(0x504, glClearColor, GLclampf, red, fp0, GLclampf, green, fp1, GLclampf, blue, fp2, GLclampf, alpha, fp3, \
  134.     , CYBERGL_BASE_NAME)
  135. GLvoid glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
  136.   glClearColor_jump(red, green, blue, alpha);
  137. }
  138.  
  139. #define glClearDepth_jump(depth) \
  140.     LP1NR(0x510, glClearDepth, GLclampd, depth, fp0, \
  141.     , CYBERGL_BASE_NAME)
  142. GLvoid glClearDepth(GLclampd depth) {
  143.   glClearDepth_jump(depth);
  144. }
  145.  
  146. #define glClearIndex_jump(index) \
  147.     LP1NR(0x50a, glClearIndex, GLfloat, index, fp0, \
  148.     , CYBERGL_BASE_NAME)
  149. GLvoid glClearIndex(GLfloat index) {
  150.   glClearIndex_jump(index);
  151. }
  152.  
  153. #define glClipPlane_jump(plane, equation) \
  154.     LP2NR(0x4f8, glClipPlane, GLenum, plane, d0, const GLdouble *, equation, a0, \
  155.     , CYBERGL_BASE_NAME)
  156. GLvoid glClipPlane(GLenum plane, const GLdouble *equation) {
  157.   glClipPlane_jump(plane, equation);
  158. }
  159.  
  160. #define glColor3b_jump(red, green, blue) \
  161.     LP3NR(0x2ac, glColor3b, GLbyte, red, d0, GLbyte, green, d1, GLbyte, blue, d2, \
  162.     , CYBERGL_BASE_NAME)
  163. GLvoid glColor3b(GLbyte red, GLbyte green, GLbyte blue) {
  164.   glColor3b_jump(red, green, blue);
  165. }
  166.  
  167. #define glColor3bv_jump(v) \
  168.     LP1NR(0x30c, glColor3bv, const GLbyte *, v, a0, \
  169.     , CYBERGL_BASE_NAME)
  170. GLvoid glColor3bv(const GLbyte *v) {
  171.   glColor3bv_jump(v);
  172. }
  173.  
  174. #define glColor3d_jump(red, green, blue) \
  175.     LP3NR(0x2c4, glColor3d, GLdouble, red, fp0, GLdouble, green, fp1, GLdouble, blue, fp2, \
  176.     , CYBERGL_BASE_NAME)
  177. GLvoid glColor3d(GLdouble red, GLdouble green, GLdouble blue) {
  178.   glColor3d_jump(red, green, blue);
  179. }
  180.  
  181. #define glColor3dv_jump(v) \
  182.     LP1NR(0x324, glColor3dv, const GLdouble *, v, a0, \
  183.     , CYBERGL_BASE_NAME)
  184. GLvoid glColor3dv(const GLdouble *v) {
  185.   glColor3dv_jump(v);
  186. }
  187.  
  188. #define glColor3f_jump(red, green, blue) \
  189.     LP3NR(0x2be, glColor3f, GLfloat, red, fp0, GLfloat, green, fp1, GLfloat, blue, fp2, \
  190.     , CYBERGL_BASE_NAME)
  191. GLvoid glColor3f(GLfloat red, GLfloat green, GLfloat blue) {
  192.   glColor3f_jump(red, green, blue);
  193. }
  194.  
  195. #define glColor3fv_jump(v) \
  196.     LP1NR(0x31e, glColor3fv, const GLfloat *, v, a0, \
  197.     , CYBERGL_BASE_NAME)
  198. GLvoid glColor3fv(const GLfloat *v) {
  199.   glColor3fv_jump(v);
  200. }
  201.  
  202. #define glColor3i_jump(red, green, blue) \
  203.     LP3NR(0x2b8, glColor3i, GLint, red, d0, GLint, green, d1, GLint, blue, d2, \
  204.     , CYBERGL_BASE_NAME)
  205. GLvoid glColor3i(GLint red, GLint green, GLint blue) {
  206.   glColor3i_jump(red, green, blue);
  207. }
  208.  
  209. #define glColor3iv_jump(v) \
  210.     LP1NR(0x318, glColor3iv, const GLint *, v, a0, \
  211.     , CYBERGL_BASE_NAME)
  212. GLvoid glColor3iv(const GLint *v) {
  213.   glColor3iv_jump(v);
  214. }
  215.  
  216. #define glColor3s_jump(red, green, blue) \
  217.     LP3NR(0x2b2, glColor3s, GLshort, red, d0, GLshort, green, d1, GLshort, blue, d2, \
  218.     , CYBERGL_BASE_NAME)
  219. GLvoid glColor3s(GLshort red, GLshort green, GLshort blue) {
  220.   glColor3s_jump(red, green, blue);
  221. }
  222.  
  223. #define glColor3sv_jump(v) \
  224.     LP1NR(0x312, glColor3sv, const GLshort *, v, a0, \
  225.     , CYBERGL_BASE_NAME)
  226. GLvoid glColor3sv(const GLshort *v) {
  227.   glColor3sv_jump(v);
  228. }
  229.  
  230. #define glColor3ub_jump(red, green, blue) \
  231.     LP3NR(0x2ca, glColor3ub, GLubyte, red, d0, GLubyte, green, d1, GLubyte, blue, d2, \
  232.     , CYBERGL_BASE_NAME)
  233. GLvoid glColor3ub(GLubyte red, GLubyte green, GLubyte blue) {
  234.   glColor3ub_jump(red, green, blue);
  235. }
  236.  
  237. #define glColor3ubv_jump(v) \
  238.     LP1NR(0x32a, glColor3ubv, const GLubyte *, v, a0, \
  239.     , CYBERGL_BASE_NAME)
  240. GLvoid glColor3ubv(const GLubyte *v) {
  241.   glColor3ubv_jump(v);
  242. }
  243.  
  244. #define glColor3ui_jump(red, green, blue) \
  245.     LP3NR(0x2d6, glColor3ui, GLuint, red, d0, GLuint, green, d1, GLuint, blue, d2, \
  246.     , CYBERGL_BASE_NAME)
  247. GLvoid glColor3ui(GLuint red, GLuint green, GLuint blue) {
  248.   glColor3ui_jump(red, green, blue);
  249. }
  250.  
  251. #define glColor3uiv_jump(v) \
  252.     LP1NR(0x336, glColor3uiv, const GLuint *, v, a0, \
  253.     , CYBERGL_BASE_NAME)
  254. GLvoid glColor3uiv(const GLuint *v) {
  255.   glColor3uiv_jump(v);
  256. }
  257.  
  258. #define glColor3us_jump(red, green, blue) \
  259.     LP3NR(0x2d0, glColor3us, GLushort, red, d0, GLushort, green, d1, GLushort, blue, d2, \
  260.     , CYBERGL_BASE_NAME)
  261. GLvoid glColor3us(GLushort red, GLushort green, GLushort blue) {
  262.   glColor3us_jump(red, green, blue);
  263. }
  264.  
  265. #define glColor3usv_jump(v) \
  266.     LP1NR(0x330, glColor3usv, const GLushort *, v, a0, \
  267.     , CYBERGL_BASE_NAME)
  268. GLvoid glColor3usv(const GLushort *v) {
  269.   glColor3usv_jump(v);
  270. }
  271.  
  272. #define glColor4b_jump(red, green, blue, alpha) \
  273.     LP4NR(0x2dc, glColor4b, GLbyte, red, d0, GLbyte, green, d1, GLbyte, blue, d2, GLbyte, alpha, d3, \
  274.     , CYBERGL_BASE_NAME)
  275. GLvoid glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) {
  276.   glColor4b_jump(red, green, blue, alpha);
  277. }
  278.  
  279. #define glColor4bv_jump(v) \
  280.     LP1NR(0x33c, glColor4bv, const GLbyte *, v, a0, \
  281.     , CYBERGL_BASE_NAME)
  282. GLvoid glColor4bv(const GLbyte *v) {
  283.   glColor4bv_jump(v);
  284. }
  285.  
  286. #define glColor4d_jump(red, green, blue, alpha) \
  287.     LP4NR(0x2f4, glColor4d, GLdouble, red, fp0, GLdouble, green, fp1, GLdouble, blue, fp2, GLdouble, alpha, fp3, \
  288.     , CYBERGL_BASE_NAME)
  289. GLvoid glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) {
  290.   glColor4d_jump(red, green, blue, alpha);
  291. }
  292.  
  293. #define glColor4dv_jump(v) \
  294.     LP1NR(0x354, glColor4dv, const GLdouble *, v, a0, \
  295.     , CYBERGL_BASE_NAME)
  296. GLvoid glColor4dv(const GLdouble *v) {
  297.   glColor4dv_jump(v);
  298. }
  299.  
  300. #define glColor4f_jump(red, green, blue, alpha) \
  301.     LP4NR(0x2ee, glColor4f, GLfloat, red, fp0, GLfloat, green, fp1, GLfloat, blue, fp2, GLfloat, alpha, fp3, \
  302.     , CYBERGL_BASE_NAME)
  303. GLvoid glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
  304.   glColor4f_jump(red, green, blue, alpha);
  305. }
  306.  
  307. #define glColor4fv_jump(v) \
  308.     LP1NR(0x34e, glColor4fv, const GLfloat *, v, a0, \
  309.     , CYBERGL_BASE_NAME)
  310. GLvoid glColor4fv(const GLfloat *v) {
  311.   glColor4fv_jump(v);
  312. }
  313.  
  314. #define glColor4i_jump(red, green, blue, alpha) \
  315.     LP4NR(0x2e8, glColor4i, GLint, red, d0, GLint, green, d1, GLint, blue, d2, GLint, alpha, d3, \
  316.     , CYBERGL_BASE_NAME)
  317. GLvoid glColor4i(GLint red, GLint green, GLint blue, GLint alpha) {
  318.   glColor4i_jump(red, green, blue, alpha);
  319. }
  320.  
  321. #define glColor4iv_jump(v) \
  322.     LP1NR(0x348, glColor4iv, const GLint *, v, a0, \
  323.     , CYBERGL_BASE_NAME)
  324. GLvoid glColor4iv(const GLint *v) {
  325.   glColor4iv_jump(v);
  326. }
  327.  
  328. #define glColor4s_jump(red, green, blue, alpha) \
  329.     LP4NR(0x2e2, glColor4s, GLshort, red, d0, GLshort, green, d1, GLshort, blue, d2, GLshort, alpha, d3, \
  330.     , CYBERGL_BASE_NAME)
  331. GLvoid glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) {
  332.   glColor4s_jump(red, green, blue, alpha);
  333. }
  334.  
  335. #define glColor4sv_jump(v) \
  336.     LP1NR(0x342, glColor4sv, const GLshort *, v, a0, \
  337.     , CYBERGL_BASE_NAME)
  338. GLvoid glColor4sv(const GLshort *v) {
  339.   glColor4sv_jump(v);
  340. }
  341.  
  342. #define glColor4ub_jump(red, green, blue, alpha) \
  343.     LP4NR(0x2fa, glColor4ub, GLubyte, red, d0, GLubyte, green, d1, GLubyte, blue, d2, GLubyte, alpha, d3, \
  344.     , CYBERGL_BASE_NAME)
  345. GLvoid glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
  346.   glColor4ub_jump(red, green, blue, alpha);
  347. }
  348.  
  349. #define glColor4ubv_jump(v) \
  350.     LP1NR(0x35a, glColor4ubv, const GLubyte *, v, a0, \
  351.     , CYBERGL_BASE_NAME)
  352. GLvoid glColor4ubv(const GLubyte *v) {
  353.   glColor4ubv_jump(v);
  354. }
  355.  
  356. #define glColor4ui_jump(red, green, blue, alpha) \
  357.     LP4NR(0x306, glColor4ui, GLuint, red, d0, GLuint, green, d1, GLuint, blue, d2, GLuint, alpha, d3, \
  358.     , CYBERGL_BASE_NAME)
  359. GLvoid glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) {
  360.   glColor4ui_jump(red, green, blue, alpha);
  361. }
  362.  
  363. #define glColor4uiv_jump(v) \
  364.     LP1NR(0x366, glColor4uiv, const GLuint *, v, a0, \
  365.     , CYBERGL_BASE_NAME)
  366. GLvoid glColor4uiv(const GLuint *v) {
  367.   glColor4uiv_jump(v);
  368. }
  369.  
  370. #define glColor4us_jump(red, green, blue, alpha) \
  371.     LP4NR(0x300, glColor4us, GLushort, red, d0, GLushort, green, d1, GLushort, blue, d2, GLushort, alpha, d3, \
  372.     , CYBERGL_BASE_NAME)
  373. GLvoid glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) {
  374.   glColor4us_jump(red, green, blue, alpha);
  375. }
  376.  
  377. #define glColor4usv_jump(v) \
  378.     LP1NR(0x360, glColor4usv, const GLushort *, v, a0, \
  379.     , CYBERGL_BASE_NAME)
  380. GLvoid glColor4usv(const GLushort *v) {
  381.   glColor4usv_jump(v);
  382. }
  383.  
  384. #define glColorMaterial_jump(face, mode) \
  385.     LP2NR(0x5d0, glColorMaterial, GLenum, face, d0, GLenum, mode, d1, \
  386.     , CYBERGL_BASE_NAME)
  387. GLvoid glColorMaterial(GLenum face, GLenum mode) {
  388.   glColorMaterial_jump(face, mode);
  389. }
  390.  
  391. #define glCullFace_jump(mode) \
  392.     LP1NR(0x558, glCullFace, GLenum, mode, d0, \
  393.     , CYBERGL_BASE_NAME)
  394. GLvoid glCullFace(GLenum mode) {
  395.   glCullFace_jump(mode);
  396. }
  397.  
  398. #define glDepthFunc_jump(func) \
  399.     LP1NR(0x546, glDepthFunc, GLenum, func, d0, \
  400.     , CYBERGL_BASE_NAME)
  401. GLvoid glDepthFunc(GLenum func) {
  402.   glDepthFunc_jump(func);
  403. }
  404.  
  405. #define glDepthRange_jump(zNear, zFar) \
  406.     LP2NR(0x468, glDepthRange, GLclampd, zNear, fp0, GLclampd, zFar, fp1, \
  407.     , CYBERGL_BASE_NAME)
  408. GLvoid glDepthRange(GLclampd zNear, GLclampd zFar) {
  409.   glDepthRange_jump(zNear, zFar);
  410. }
  411.  
  412. #define glDisable_jump(cap) \
  413.     LP1NR(0x72, glDisable, GLenum, cap, d0, \
  414.     , CYBERGL_BASE_NAME)
  415. GLvoid glDisable(GLenum cap) {
  416.   glDisable_jump(cap);
  417. }
  418.  
  419. #define glDrawBuffer_jump(mode) \
  420.     LP1NR(0x528, glDrawBuffer, GLenum, mode, d0, \
  421.     , CYBERGL_BASE_NAME)
  422. GLvoid glDrawBuffer(GLenum mode) {
  423.   glDrawBuffer_jump(mode);
  424. }
  425.  
  426. #define glDrawPixels_jump(width, height, format, type, data) \
  427.     LP5NR(0x666, glDrawPixels, GLsizei, width, d0, GLsizei, height, d1, GLenum, format, d2, GLenum, type, d3, const GLvoid *, data, a0, \
  428.     , CYBERGL_BASE_NAME)
  429. GLvoid glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data) {
  430.   glDrawPixels_jump(width, height, format, type, data);
  431. }
  432.  
  433. #define glEdgeFlag_jump(flag) \
  434.     LP1NR(0x3cc, glEdgeFlag, GLboolean, flag, d0, \
  435.     , CYBERGL_BASE_NAME)
  436. GLvoid glEdgeFlag(GLboolean flag) {
  437.   glEdgeFlag_jump(flag);
  438. }
  439.  
  440. #define glEdgeFlagv_jump(flag) \
  441.     LP1NR(0x3d2, glEdgeFlagv, const GLboolean *, flag, a0, \
  442.     , CYBERGL_BASE_NAME)
  443. GLvoid glEdgeFlagv(const GLboolean *flag) {
  444.   glEdgeFlagv_jump(flag);
  445. }
  446.  
  447. #define glEnable_jump(cap) \
  448.     LP1NR(0x6c, glEnable, GLenum, cap, d0, \
  449.     , CYBERGL_BASE_NAME)
  450. GLvoid glEnable (GLenum cap) {
  451.   glEnable_jump(cap);
  452. }
  453.  
  454. #define glEnd_jump() \
  455.     LP0NR(0x11a, glEnd, \
  456.     , CYBERGL_BASE_NAME)
  457. GLvoid glEnd(GLvoid) {
  458.   glEnd_jump();
  459. }
  460.  
  461. #define glFinish_jump() \
  462.     LP0NR(0x51c, glFinish, \
  463.     , CYBERGL_BASE_NAME)
  464. GLvoid glFinish(GLvoid) {
  465.   glFinish_jump();
  466. }
  467.  
  468. #define glFlush_jump() \
  469.     LP0NR(0x516, glFlush, \
  470.     , CYBERGL_BASE_NAME)
  471. GLvoid glFlush(GLvoid) {
  472.   glFlush_jump();
  473. }
  474.  
  475. #define glFogf_jump(pname, param) \
  476.     LP2NR(0x52e, glFogf, GLenum, pname, d0, GLfloat, param, fp0, \
  477.     , CYBERGL_BASE_NAME)
  478. GLvoid glFogf(GLenum pname, GLfloat param) {
  479.   glFogf_jump(pname, param);
  480. }
  481.  
  482. #define glFogfv_jump(pname, params) \
  483.     LP2NR(0x53a, glFogfv, GLenum, pname, d0, const GLfloat *, params, a0, \
  484.     , CYBERGL_BASE_NAME)
  485. GLvoid glFogfv(GLenum pname, const GLfloat *params) {
  486.   glFogfv_jump(pname, params);
  487. }
  488.  
  489. #define glFogi_jump(pname, param) \
  490.     LP2NR(0x534, glFogi, GLenum, pname, d0, GLint, param, d1, \
  491.     , CYBERGL_BASE_NAME)
  492. GLvoid glFogi(GLenum pname, GLint param) {
  493.   glFogi_jump(pname, param);
  494. }
  495.  
  496. #define glFogiv_jump(pname, params) \
  497.     LP2NR(0x540, glFogiv, GLenum, pname, d0, const GLint *, params, a0, \
  498.     , CYBERGL_BASE_NAME)
  499. GLvoid glFogiv(GLenum pname, const GLint *params) {
  500.   glFogiv_jump(pname, params);
  501. }
  502.  
  503. #define glFrontFace_jump(mode) \
  504.     LP1NR(0x55e, glFrontFace, GLenum, mode, d0, \
  505.     , CYBERGL_BASE_NAME)
  506. GLvoid glFrontFace(GLenum mode) {
  507.   glFrontFace_jump(mode);
  508. }
  509.  
  510. #define glFrustum_jump(frustum) \
  511.     LP1NR(0x4c2, glFrustum, const GLfrustum *, frustum, a0, \
  512.     , CYBERGL_BASE_NAME)
  513. GLvoid glFrustum(GLdouble left,  GLdouble right, GLdouble bottom, GLdouble top,
  514.                                  GLdouble zNear, GLdouble zFar) {
  515.   GLfrustum sfrustum;
  516.   
  517.   sfrustum.left = left;
  518.   sfrustum.right = right;
  519.   sfrustum.bottom = bottom;
  520.   sfrustum.top = top;
  521.   sfrustum.zNear = zNear;
  522.   sfrustum.zFar = zFar;
  523.   
  524.   glFrustum_jump(&sfrustum);
  525. }
  526.  
  527. #define glGetBooleanv_jump(pname, params) \
  528.     LP2NR(0x7e, glGetBooleanv, GLenum, pname, d0, GLboolean *, params, a0, \
  529.     , CYBERGL_BASE_NAME)
  530. GLvoid glGetBooleanv(GLenum pname, GLboolean *params) {
  531.   glGetBooleanv_jump(pname, params);
  532. }
  533.  
  534. #define glGetClipPlane_jump(plane, equation) \
  535.     LP2NR(0x96, glGetClipPlane, GLenum, plane, d0, GLdouble *, equation, a0, \
  536.     , CYBERGL_BASE_NAME)
  537. GLvoid glGetClipPlane(GLenum plane, GLdouble *equation) {
  538.   glGetClipPlane_jump(plane, equation);
  539. }
  540.  
  541. #define glGetDoublev_jump(pname, params) \
  542.     LP2NR(0x90, glGetDoublev, GLenum, pname, d0, GLdouble *, params, a0, \
  543.     , CYBERGL_BASE_NAME)
  544. GLvoid glGetDoublev(GLenum pname, GLdouble *params) {
  545.   glGetDoublev_jump(pname, params);
  546. }
  547.  
  548. #define glGetError_jump() \
  549.     LP0(0x66, GLenum, glGetError, \
  550.     , CYBERGL_BASE_NAME)
  551. GLenum glGetError(GLvoid) {
  552.   return glGetError_jump();
  553. }
  554.  
  555. #define glGetFloatv_jump(pname, params) \
  556.     LP2NR(0x8a, glGetFloatv, GLenum, pname, d0, GLfloat *, params, a0, \
  557.     , CYBERGL_BASE_NAME)
  558. GLvoid glGetFloatv(GLenum pname, GLfloat *params) {
  559.   glGetFloatv_jump(pname, params);
  560. }
  561.  
  562. #define glGetIntegerv_jump(pname, params) \
  563.     LP2NR(0x84, glGetIntegerv, GLenum, pname, d0, GLint *, params, a0, \
  564.     , CYBERGL_BASE_NAME)
  565. GLvoid glGetIntegerv(GLenum pname, GLint *params) {
  566.   glGetIntegerv_jump(pname, params);
  567. }
  568.  
  569. #define glGetLightfv_jump(light, pname, params) \
  570.     LP3NR(0x9c, glGetLightfv, GLenum, light, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  571.     , CYBERGL_BASE_NAME)
  572. GLvoid glGetLightfv(GLenum light, GLenum pname, GLfloat *params) {
  573.   glGetLightfv_jump(light, pname, params);
  574. }
  575.  
  576. #define glGetLightiv_jump(light, pname, params) \
  577.     LP3NR(0xa2, glGetLightiv, GLenum, light, d0, GLenum, pname, d1, GLint *, params, a0, \
  578.     , CYBERGL_BASE_NAME)
  579. GLvoid glGetLightiv(GLenum light, GLenum pname, GLint *params) {
  580.   glGetLightiv_jump(light, pname, params);
  581. }
  582.  
  583. #define glGetMaterialfv_jump(face, pname, params) \
  584.     LP3NR(0xa8, glGetMaterialfv, GLenum, face, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  585.     , CYBERGL_BASE_NAME)
  586. GLvoid glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) {
  587.   glGetMaterialfv_jump(face, pname, params);
  588. }
  589.  
  590. #define glGetMaterialiv_jump(face, pname, params) \
  591.     LP3NR(0xae, glGetMaterialiv, GLenum, face, d0, GLenum, pname, d1, GLint *, params, a0, \
  592.     , CYBERGL_BASE_NAME)
  593. GLvoid glGetMaterialiv(GLenum face, GLenum pname, GLint *params) {
  594.   glGetMaterialiv_jump(face, pname, params);
  595. }
  596.  
  597. #define glGetPixelMapfv_jump(map, values) \
  598.     LP2NR(0xc6, glGetPixelMapfv, GLenum, map, d0, GLfloat *, values, a0, \
  599.     , CYBERGL_BASE_NAME)
  600. GLvoid glGetPixelMapfv(GLenum map, GLfloat *values) {
  601.   glGetPixelMapfv_jump(map, values);
  602. }
  603.  
  604. #define glGetPixelMapuiv_jump(map, values) \
  605.     LP2NR(0xcc, glGetPixelMapuiv, GLenum, map, d0, GLuint *, values, a0, \
  606.     , CYBERGL_BASE_NAME)
  607. GLvoid glGetPixelMapuiv(GLenum map, GLuint *values) {
  608.   glGetPixelMapuiv_jump(map, values);
  609. }
  610.  
  611. #define glGetPixelMapusv_jump(map, values) \
  612.     LP2NR(0xd2, glGetPixelMapusv, GLenum, map, d0, GLushort *, values, a0, \
  613.     , CYBERGL_BASE_NAME)
  614. GLvoid glGetPixelMapusv(GLenum map, GLushort *values) {
  615.   glGetPixelMapusv_jump(map, values);
  616. }
  617.  
  618. #define glGetString_jump(name) \
  619.     LP1(0x102, GLubyte *, glGetString, GLenum, name, d0, \
  620.     , CYBERGL_BASE_NAME)
  621. GLubyte *glGetString(GLenum name) {
  622.   return glGetString_jump(name);
  623. }
  624.  
  625. #define glGetTexEnvfv_jump(target, pname, params) \
  626.     LP3NR(0xd8, glGetTexEnvfv, GLenum, target, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  627.     , CYBERGL_BASE_NAME)
  628. GLvoid glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) {
  629.   glGetTexEnvfv_jump(target, pname, params);
  630. }
  631.  
  632. #define glGetTexEnviv_jump(target, pname, params) \
  633.     LP3NR(0xde, glGetTexEnviv, GLenum, target, d0, GLenum, pname, d1, GLint *, params, a0, \
  634.     , CYBERGL_BASE_NAME)
  635. GLvoid glGetTexEnviv(GLenum target, GLenum pname, GLint *params) {
  636.   glGetTexEnviv_jump(target, pname, params);
  637. }
  638.  
  639. #define glGetTexGendv_jump(coord, pname, params) \
  640.     LP3NR(0xb4, glGetTexGendv, GLenum, coord, d0, GLenum, pname, d1, GLdouble *, params, a0, \
  641.     , CYBERGL_BASE_NAME)
  642. GLvoid glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) {
  643.   glGetTexGendv_jump(coord, pname, params);
  644. }
  645.  
  646. #define glGetTexGenfv_jump(coord, pname, params) \
  647.     LP3NR(0xba, glGetTexGenfv, GLenum, coord, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  648.     , CYBERGL_BASE_NAME)
  649. GLvoid glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) {
  650.   glGetTexGenfv_jump(coord, pname, params);
  651. }
  652.  
  653. #define glGetTexGeniv_jump(coord, pname, params) \
  654.     LP3NR(0xc0, glGetTexGeniv, GLenum, coord, d0, GLenum, pname, d1, GLint *, params, a0, \
  655.     , CYBERGL_BASE_NAME)
  656. GLvoid glGetTexGeniv(GLenum coord, GLenum pname, GLint *params) {
  657.   glGetTexGeniv_jump(coord, pname, params);
  658. }
  659.  
  660. #define glGetTexImage_jump(target, level, format, type, pixels) \
  661.     LP5NR(0xfc, glGetTexImage, GLenum, target, d0, GLint, level, d1, GLenum, format, d2, GLenum, type, d3, GLvoid *, pixels, a0, \
  662.     , CYBERGL_BASE_NAME)
  663. GLvoid glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {
  664.   glGetTexImage_jump(target, level, format, type, pixels);
  665. }
  666.  
  667. #define glGetTexLevelParameterfv_jump(target, level, pname, params) \
  668.     LP4NR(0xe4, glGetTexLevelParameterfv, GLenum, target, d0, GLint, level, d1, GLenum, pname, d2, GLfloat *, params, a0, \
  669.     , CYBERGL_BASE_NAME)
  670. GLvoid glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {
  671.   glGetTexLevelParameterfv_jump(target, level, pname, params);
  672. }
  673.  
  674. #define glGetTexLevelParameteriv_jump(target, level, pname, params) \
  675.     LP4NR(0xea, glGetTexLevelParameteriv, GLenum, target, d0, GLint, level, d1, GLenum, pname, d2, GLint *, params, a0, \
  676.     , CYBERGL_BASE_NAME)
  677. GLvoid glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {
  678.   glGetTexLevelParameteriv_jump(target, level, pname, params);
  679. }
  680.  
  681. #define glGetTexParameterfv_jump(target, pname, params) \
  682.     LP3NR(0xf0, glGetTexParameterfv, GLenum, target, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  683.     , CYBERGL_BASE_NAME)
  684. GLvoid glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {
  685.   glGetTexParameterfv_jump(target, pname, params);
  686. }
  687.  
  688. #define glGetTexParameteriv_jump(target, pname, params) \
  689.     LP3NR(0xf6, glGetTexParameteriv, GLenum, target, d0, GLenum, pname, d1, GLint *, params, a0, \
  690.     , CYBERGL_BASE_NAME)
  691. GLvoid glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {
  692.   glGetTexParameteriv_jump(target, pname, params);
  693. }
  694.  
  695. #define glHint_jump(target, mode) \
  696.     LP2NR(0x522, glHint, GLenum, target, d0, GLenum, mode, d1, \
  697.     , CYBERGL_BASE_NAME)
  698. GLvoid glHint(GLenum target, GLenum mode) {
  699.   glHint_jump(target, mode);
  700. }
  701.  
  702. #define glIndexd_jump(index) \
  703.     LP1NR(0x37e, glIndexd, GLdouble, index, fp0, \
  704.     , CYBERGL_BASE_NAME)
  705. GLvoid glIndexd(GLdouble index) {
  706.   glIndexd_jump(index);
  707. }
  708.  
  709. #define glIndexdv_jump(v) \
  710.     LP1NR(0x396, glIndexdv, const GLdouble *, v, a0, \
  711.     , CYBERGL_BASE_NAME)
  712. GLvoid glIndexdv(const GLdouble *v) {
  713.   glIndexdv_jump(v);
  714. }
  715.  
  716. #define glIndexf_jump(index) \
  717.     LP1NR(0x378, glIndexf, GLfloat, index, fp0, \
  718.     , CYBERGL_BASE_NAME)
  719. GLvoid glIndexf(GLfloat index) {
  720.   glIndexf_jump(index);
  721. }
  722.  
  723. #define glIndexfv_jump(v) \
  724.     LP1NR(0x390, glIndexfv, const GLfloat *, v, a0, \
  725.     , CYBERGL_BASE_NAME)
  726. GLvoid glIndexfv(const GLfloat *v) {
  727.   glIndexfv_jump(v);
  728. }
  729.  
  730. #define glIndexi_jump(index) \
  731.     LP1NR(0x372, glIndexi, GLint, index, d0, \
  732.     , CYBERGL_BASE_NAME)
  733. GLvoid glIndexi(GLint index) {
  734.   glIndexi_jump(index);
  735. }
  736.  
  737. #define glIndexiv_jump(v) \
  738.     LP1NR(0x38a, glIndexiv, const GLint *, v, a0, \
  739.     , CYBERGL_BASE_NAME)
  740. GLvoid glIndexiv(const GLint *v) {
  741.   glIndexiv_jump(v);
  742. }
  743.  
  744. #define glIndexs_jump(index) \
  745.     LP1NR(0x36c, glIndexs, GLshort, index, d0, \
  746.     , CYBERGL_BASE_NAME)
  747. GLvoid glIndexs(GLshort index) {
  748.   glIndexs_jump(index);
  749. }
  750.  
  751. #define glIndexsv_jump(v) \
  752.     LP1NR(0x384, glIndexsv, const GLshort *, v, a0, \
  753.     , CYBERGL_BASE_NAME)
  754. GLvoid glIndexsv(const GLshort *v) {
  755.   glIndexsv_jump(v);
  756. }
  757.  
  758. #define glInitNames_jump() \
  759.     LP0NR(0x56a, glInitNames, \
  760.     , CYBERGL_BASE_NAME)
  761. GLvoid glInitNames(GLvoid) {
  762.   glInitNames_jump();
  763. }
  764.  
  765. #define glIsEnabled_jump(cap) \
  766.     LP1(0x78, GLboolean, glIsEnabled, GLenum, cap, d0, \
  767.     , CYBERGL_BASE_NAME)
  768. GLboolean glIsEnabled(GLenum cap) {
  769.   return glIsEnabled_jump(cap);
  770. }
  771.  
  772. #define glLightModelf_jump(pname, param) \
  773.     LP2NR(0x5a0, glLightModelf, GLenum, pname, d0, GLfloat, param, fp0, \
  774.     , CYBERGL_BASE_NAME)
  775. GLvoid glLightModelf(GLenum pname, GLfloat param) {
  776.   glLightModelf_jump(pname, param);
  777. }
  778.  
  779. #define glLightModelfv_jump(pname, params) \
  780.     LP2NR(0x5ac, glLightModelfv, GLenum, pname, d0, GLfloat *, params, a0, \
  781.     , CYBERGL_BASE_NAME)
  782. GLvoid glLightModelfv(GLenum pname, GLfloat *params) {
  783.   glLightModelfv_jump(pname, params);
  784. }
  785.  
  786. #define glLightModeli_jump(pname, param) \
  787.     LP2NR(0x5a6, glLightModeli, GLenum, pname, d0, GLint, param, d1, \
  788.     , CYBERGL_BASE_NAME)
  789. GLvoid glLightModeli(GLenum pname, GLint param) {
  790.   glLightModeli_jump(pname, param);
  791. }
  792.  
  793. #define glLightModeliv_jump(pname, params) \
  794.     LP2NR(0x5b2, glLightModeliv, GLenum, pname, d0, GLint *, params, a0, \
  795.     , CYBERGL_BASE_NAME)
  796. GLvoid glLightModeliv(GLenum pname, GLint *params) {
  797.   glLightModeliv_jump(pname, params);
  798. }
  799.  
  800. #define glLightf_jump(light, pname, param) \
  801.     LP3NR(0x588, glLightf, GLenum, light, d0, GLenum, pname, d1, GLfloat, param, fp0, \
  802.     , CYBERGL_BASE_NAME)
  803. GLvoid glLightf(GLenum light, GLenum pname, GLfloat param) {
  804.   glLightf_jump(light, pname, param);
  805. }
  806.  
  807. #define glLightfv_jump(light, pname, params) \
  808.     LP3NR(0x594, glLightfv, GLenum, light, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  809.     , CYBERGL_BASE_NAME)
  810. GLvoid glLightfv(GLenum light, GLenum pname, GLfloat *params) {
  811.   glLightfv_jump(light, pname, params);
  812. }
  813.  
  814. #define glLighti_jump(light, pname, param) \
  815.     LP3NR(0x58e, glLighti, GLenum, light, d0, GLenum, pname, d1, GLint, param, d2, \
  816.     , CYBERGL_BASE_NAME)
  817. GLvoid glLighti(GLenum light, GLenum pname, GLint param) {
  818.   glLighti_jump(light, pname, param);
  819. }
  820.  
  821. #define glLightiv_jump(light, pname, params) \
  822.     LP3NR(0x59a, glLightiv, GLenum, light, d0, GLenum, pname, d1, GLint *, params, a0, \
  823.     , CYBERGL_BASE_NAME)
  824. GLvoid glLightiv(GLenum light, GLenum pname, GLint *params) {
  825.   glLightiv_jump(light, pname, params);
  826. }
  827.  
  828. #define glLoadIdentity_jump() \
  829.     LP0NR(0x492, glLoadIdentity, \
  830.     , CYBERGL_BASE_NAME)
  831. GLvoid glLoadIdentity(GLvoid) {
  832.   glLoadIdentity_jump();
  833. }
  834.  
  835. #define glLoadMatrixd_jump(m) \
  836.     LP1NR(0x480, glLoadMatrixd, const GLdouble *, m, a0, \
  837.     , CYBERGL_BASE_NAME)
  838. GLvoid glLoadMatrixd(const GLdouble *m) {
  839.   glLoadMatrixd_jump(m);
  840. }
  841.  
  842. #define glLoadMatrixf_jump(m) \
  843.     LP1NR(0x47a, glLoadMatrixf, const GLfloat *, m, a0, \
  844.     , CYBERGL_BASE_NAME)
  845. GLvoid glLoadMatrixf(const GLfloat *m) {
  846.   glLoadMatrixf_jump(m);
  847. }
  848.  
  849. #define glLoadName_jump(name) \
  850.     LP1NR(0x570, glLoadName, GLuint, name, d0, \
  851.     , CYBERGL_BASE_NAME)
  852. GLvoid glLoadName(GLuint name) {
  853.   glLoadName_jump(name);
  854. }
  855.  
  856. #define glLookAt_jump(lookAt) \
  857.     LP1NR(0x4ec, glLookAt, const GLlookAt *, lookAt, a0, \
  858.     , CYBERGL_BASE_NAME)
  859. GLvoid glLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, 
  860.                                 GLdouble centerx, GLdouble centery, GLdouble centerz, 
  861.                                 GLdouble upx, GLdouble upy, GLdouble upz) {
  862.   GLlookAt slookat;
  863.   
  864.   slookat.eyex = eyex;
  865.   slookat.eyey = eyey;
  866.   slookat.eyez = eyez;
  867.   slookat.centerx = centerx;
  868.   slookat.centery = centery;
  869.   slookat.centerz = centerz;
  870.   slookat.upx = upx;
  871.   slookat.upy = upy;
  872.   slookat.upz = upz;
  873.   
  874.   glLookAt_jump(&slookat);
  875. }
  876.  
  877. #define glMaterialf_jump(face, pname, param) \
  878.     LP3NR(0x5b8, glMaterialf, GLenum, face, d0, GLenum, pname, d1, GLfloat, param, fp0, \
  879.     , CYBERGL_BASE_NAME)
  880. GLvoid glMaterialf(GLenum face, GLenum pname, GLfloat param) {
  881.   glMaterialf_jump(face, pname, param);
  882. }
  883.  
  884. #define glMaterialfv_jump(face, pname, params) \
  885.     LP3NR(0x5c4, glMaterialfv, GLenum, face, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  886.     , CYBERGL_BASE_NAME)
  887. GLvoid glMaterialfv(GLenum face, GLenum pname, GLfloat *params) {
  888.   glMaterialfv_jump(face, pname, params);
  889. }
  890.  
  891. #define glMateriali_jump(face, pname, param) \
  892.     LP3NR(0x5be, glMateriali, GLenum, face, d0, GLenum, pname, d1, GLint, param, d2, \
  893.     , CYBERGL_BASE_NAME)
  894. GLvoid glMateriali(GLenum face, GLenum pname, GLint param) {
  895.   glMateriali_jump(face, pname, param);
  896. }
  897.  
  898. #define glMaterialiv_jump(face, pname, params) \
  899.     LP3NR(0x5ca, glMaterialiv, GLenum, face, d0, GLenum, pname, d1, GLint *, params, a0, \
  900.     , CYBERGL_BASE_NAME)
  901. GLvoid glMaterialiv(GLenum face, GLenum pname, GLint *params) {
  902.   glMaterialiv_jump(face, pname, params);
  903. }
  904.  
  905. #define glMatrixMode_jump(mode) \
  906.     LP1NR(0x474, glMatrixMode, GLenum, mode, d0, \
  907.     , CYBERGL_BASE_NAME)
  908. GLvoid glMatrixMode(GLenum mode) {
  909.   glMatrixMode_jump(mode);
  910. }
  911.  
  912. #define glMultMatrixd_jump(m) \
  913.     LP1NR(0x48c, glMultMatrixd, const GLdouble *, m, a0, \
  914.     , CYBERGL_BASE_NAME)
  915. GLvoid glMultMatrixd(const GLdouble *m) {
  916.   glMultMatrixd_jump(m);
  917. }
  918.  
  919. #define glMultMatrixf_jump(m) \
  920.     LP1NR(0x486, glMultMatrixf, const GLfloat *, m, a0, \
  921.     , CYBERGL_BASE_NAME)
  922. GLvoid glMultMatrixf(const GLfloat *m) {
  923.   glMultMatrixf_jump(m);
  924. }
  925.  
  926. #define glNormal3b_jump(nx, ny, nz) \
  927.     LP3NR(0x270, glNormal3b, GLbyte, nx, d0, GLbyte, ny, d1, GLbyte, nz, d2, \
  928.     , CYBERGL_BASE_NAME)
  929. GLvoid glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) {
  930.   glNormal3b_jump(nx, ny, nz);
  931. }
  932.  
  933. #define glNormal3bv_jump(v) \
  934.     LP1NR(0x28e, glNormal3bv, const GLbyte *, v, a0, \
  935.     , CYBERGL_BASE_NAME)
  936. GLvoid glNormal3bv(const GLbyte *v) {
  937.   glNormal3bv_jump(v);
  938. }
  939.  
  940. #define glNormal3d_jump(nx, ny, nz) \
  941.     LP3NR(0x288, glNormal3d, GLdouble, nx, fp0, GLdouble, ny, fp1, GLdouble, nz, fp2, \
  942.     , CYBERGL_BASE_NAME)
  943. GLvoid glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) {
  944.   glNormal3d_jump(nx, ny, nz);
  945. }
  946.  
  947. #define glNormal3dv_jump(v) \
  948.     LP1NR(0x2a6, glNormal3dv, const GLdouble *, v, a0, \
  949.     , CYBERGL_BASE_NAME)
  950. GLvoid glNormal3dv(const GLdouble *v) {
  951.   glNormal3dv_jump(v);
  952. }
  953.  
  954. #define glNormal3f_jump(nx, ny, nz) \
  955.     LP3NR(0x282, glNormal3f, GLfloat, nx, fp0, GLfloat, ny, fp1, GLfloat, nz, fp2, \
  956.     , CYBERGL_BASE_NAME)
  957. GLvoid glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {
  958.   glNormal3f_jump(nx, ny, nz);
  959. }
  960.  
  961. #define glNormal3fv_jump(v) \
  962.     LP1NR(0x2a0, glNormal3fv, const GLfloat *, v, a0, \
  963.     , CYBERGL_BASE_NAME)
  964. GLvoid glNormal3fv(const GLfloat *v) {
  965.   glNormal3fv_jump(v);
  966. }
  967.  
  968. #define glNormal3i_jump(nx, ny, nz) \
  969.     LP3NR(0x27c, glNormal3i, GLint, nx, d0, GLint, ny, d1, GLint, nz, d2, \
  970.     , CYBERGL_BASE_NAME)
  971. GLvoid glNormal3i(GLint nx, GLint ny, GLint nz) {
  972.   glNormal3i_jump(nx, ny, nz);
  973. }
  974.  
  975. #define glNormal3iv_jump(v) \
  976.     LP1NR(0x29a, glNormal3iv, const GLint *, v, a0, \
  977.     , CYBERGL_BASE_NAME)
  978. GLvoid glNormal3iv(const GLint *v) {
  979.   glNormal3iv_jump(v);
  980. }
  981.  
  982. #define glNormal3s_jump(nx, ny, nz) \
  983.     LP3NR(0x276, glNormal3s, GLshort, nx, d0, GLshort, ny, d1, GLshort, nz, d2, \
  984.     , CYBERGL_BASE_NAME)
  985. GLvoid glNormal3s(GLshort nx, GLshort ny, GLshort nz) {
  986.   glNormal3s_jump(nx, ny, nz);
  987. }
  988.  
  989. #define glNormal3sv_jump(v) \
  990.     LP1NR(0x294, glNormal3sv, const GLshort *, v, a0, \
  991.     , CYBERGL_BASE_NAME)
  992. GLvoid glNormal3sv(const GLshort *v) {
  993.   glNormal3sv_jump(v);
  994. }
  995.  
  996. #define glOrtho_jump(ortho) \
  997.     LP1NR(0x4c2, glOrtho, const GLortho *, ortho, a0, \
  998.     , CYBERGL_BASE_NAME)
  999. GLvoid glOrtho(GLdouble left,  GLdouble right, GLdouble bottom, GLdouble top,
  1000.                                GLdouble zNear, GLdouble zFar) {
  1001.   GLortho sortho;
  1002.   
  1003.   sortho.left = left;
  1004.   sortho.right = right;
  1005.   sortho.bottom = bottom;
  1006.   sortho.top = top;
  1007.   sortho.zNear = zNear;
  1008.   sortho.zFar = zFar;
  1009.   
  1010.   glOrtho_jump(&sortho);
  1011. }
  1012.  
  1013. #define glOrtho2D_jump(left, right, bottom, top) \
  1014.     LP4NR(0x4d4, glOrtho2D, GLdouble, left, fp0, GLdouble, right, fp1, GLdouble, bottom, fp2, GLdouble, top, fp3, \
  1015.     , CYBERGL_BASE_NAME)
  1016. GLvoid glOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top) {
  1017.   glOrtho2D_jump(left, right, bottom, top);
  1018. }
  1019.  
  1020. #define glPerspective_jump(fovy, aspect, zNear, zFar) \
  1021.     LP4NR(0x4e6, glPerspective, GLdouble, fovy, fp0, GLdouble, aspect, fp1, GLdouble, zNear, fp2, GLdouble, zFar, fp3, \
  1022.     , CYBERGL_BASE_NAME)
  1023. GLvoid glPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar) {
  1024.   glPerspective_jump(fovy, aspect, zNear, zFar);
  1025. }
  1026.  
  1027. #define glPickMatrix_jump(x, y, width, height) \
  1028.     LP4NR(0x4f2, glPickMatrix, GLdouble, x, fp0, GLdouble, y, fp1, GLdouble, width, fp2, GLdouble, height, fp3, \
  1029.     , CYBERGL_BASE_NAME)
  1030. GLvoid glPickMatrix(GLdouble x, GLdouble y, GLdouble width, GLdouble height) {
  1031.   glPickMatrix_jump(x, y, width, height);
  1032. }
  1033.  
  1034. #define glPixelMapfv_jump(map, mapsize, values) \
  1035.     LP3NR(0x65a, glPixelMapfv, GLenum, map, d0, GLsizei, mapsize, d1, const GLfloat *, values, a0, \
  1036.     , CYBERGL_BASE_NAME)
  1037. GLvoid glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values) {
  1038.   glPixelMapfv_jump(map, mapsize, values);
  1039. }
  1040.  
  1041. #define glPixelMapuiv_jump(map, mapsize, values) \
  1042.     LP3NR(0x64e, glPixelMapuiv, GLenum, map, d0, GLsizei, mapsize, d1, const GLuint *, values, a0, \
  1043.     , CYBERGL_BASE_NAME)
  1044. GLvoid glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values) {
  1045.   glPixelMapuiv_jump(map, mapsize, values);
  1046. }
  1047.  
  1048. #define glPixelMapusv_jump(map, mapsize, values) \
  1049.     LP3NR(0x654, glPixelMapusv, GLenum, map, d0, GLsizei, mapsize, d1, const GLushort *, values, a0, \
  1050.     , CYBERGL_BASE_NAME)
  1051. GLvoid glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values) {
  1052.   glPixelMapusv_jump(map, mapsize, values);
  1053. }
  1054.  
  1055. #define glPixelStoref_jump(pname, param) \
  1056.     LP2NR(0x63c, glPixelStoref, GLenum, pname, d0, GLfloat, param, fp0, \
  1057.     , CYBERGL_BASE_NAME)
  1058. GLvoid glPixelStoref(GLenum pname, GLfloat param) {
  1059.   glPixelStoref_jump(pname, param);
  1060. }
  1061.  
  1062. #define glPixelStorei_jump(pname, param) \
  1063.     LP2NR(0x636, glPixelStorei, GLenum, pname, d0, GLint, param, d1, \
  1064.     , CYBERGL_BASE_NAME)
  1065. GLvoid glPixelStorei(GLenum pname, GLint param) {
  1066.   glPixelStorei_jump(pname, param);
  1067. }
  1068.  
  1069. #define glPixelTransferf_jump(pname, param) \
  1070.     LP2NR(0x648, glPixelTransferf, GLenum, pname, d0, GLfloat, param, fp0, \
  1071.     , CYBERGL_BASE_NAME)
  1072. GLvoid glPixelTransferf(GLenum pname, GLfloat param) {
  1073.   glPixelTransferf_jump(pname, param);
  1074. }
  1075.  
  1076. #define glPixelTransferi_jump(pname, param) \
  1077.     LP2NR(0x642, glPixelTransferi, GLenum, pname, d0, GLint, param, d1, \
  1078.     , CYBERGL_BASE_NAME)
  1079. GLvoid glPixelTransferi(GLenum pname, GLint param) {
  1080.   glPixelTransferi_jump(pname, param);
  1081. }
  1082.  
  1083. #define glPixelZoom_jump(xfactor, yfactor) \
  1084.     LP2NR(0x660, glPixelZoom, GLfloat, xfactor, fp0, GLfloat, yfactor, fp1, \
  1085.     , CYBERGL_BASE_NAME)
  1086. GLvoid glPixelZoom(GLfloat xfactor, GLfloat yfactor) {
  1087.   glPixelZoom_jump(xfactor, yfactor);
  1088. }
  1089.  
  1090. #define glPolygonMode_jump(face, mode) \
  1091.     LP2NR(0x54c, glPolygonMode, GLenum, face, d0, GLenum, mode, d1, \
  1092.     , CYBERGL_BASE_NAME)
  1093. GLvoid glPolygonMode(GLenum face, GLenum mode) {
  1094.   glPolygonMode_jump(face, mode);
  1095. }
  1096.  
  1097. #define glPopAttrib_jump() \
  1098.     LP0NR(0x10e, glPopAttrib, \
  1099.     , CYBERGL_BASE_NAME)
  1100. GLvoid glPopAttrib(GLvoid) {
  1101.   glPopAttrib_jump();
  1102. }
  1103.  
  1104. #define glPopMatrix_jump() \
  1105.     LP0NR(0x4ce, glPopMatrix, \
  1106.     , CYBERGL_BASE_NAME)
  1107. GLvoid glPopMatrix(GLvoid) {
  1108.   glPopMatrix_jump();
  1109. }
  1110.  
  1111. #define glPopName_jump() \
  1112.     LP0NR(0x57c, glPopName, \
  1113.     , CYBERGL_BASE_NAME)
  1114. GLvoid glPopName(GLvoid) {
  1115.   glPopName_jump();
  1116. }
  1117.  
  1118. /*
  1119.  * probably wrong
  1120.  */
  1121. #define glProject_jump(objx, objy, objz, winx, winy, winz) \
  1122.     LP6(0x4da, GLboolean, glProject, GLdouble, objx, fp0, GLdouble, objy, fp1, GLdouble, objz, fp2, GLdouble *, winx, a0, GLdouble *, winy, a1, GLdouble *, winz, a2, \
  1123.     , CYBERGL_BASE_NAME)
  1124. GLboolean glProject(GLdouble objx, GLdouble objy, GLdouble objz, GLdouble *winx, GLdouble *winy, GLdouble *winz) {
  1125.   glProject_jump(objx, objy, objz, winx, winy, winz);
  1126. }
  1127.  
  1128. #define glPushAttrib_jump(mask) \
  1129.     LP1NR(0x108, glPushAttrib, GLbitfield, mask, d0, \
  1130.     , CYBERGL_BASE_NAME)
  1131. GLvoid glPushAttrib(GLbitfield mask) {
  1132.   glPushAttrib_jump(mask);
  1133. }
  1134.  
  1135. #define glPushMatrix_jump() \
  1136.     LP0NR(0x4c8, glPushMatrix, \
  1137.     , CYBERGL_BASE_NAME)
  1138. GLvoid glPushMatrix(GLvoid) {
  1139.   glPushMatrix_jump();
  1140. }
  1141.  
  1142. #define glPushName_jump(name) \
  1143.     LP1NR(0x576, glPushName, GLuint, name, d0, \
  1144.     , CYBERGL_BASE_NAME)
  1145. GLvoid glPushName(GLuint name) {
  1146.   glPushName_jump(name);
  1147. }
  1148.  
  1149. #define glRasterPos2d_jump(s, t) \
  1150.     LP2NR(0x3ea, glRasterPos2d, GLdouble, s, fp0, GLdouble, t, fp1, \
  1151.     , CYBERGL_BASE_NAME)
  1152. GLvoid glRasterPos2d(GLdouble s, GLdouble t) {
  1153.   glRasterPos2d_jump(s, t);
  1154. }
  1155.  
  1156. #define glRasterPos2dv_jump(v) \
  1157.     LP1NR(0x432, glRasterPos2dv, const GLdouble *, v, a0, \
  1158.     , CYBERGL_BASE_NAME)
  1159. GLvoid glRasterPos2dv(const GLdouble *v) {
  1160.   glRasterPos2dv_jump(v);
  1161. }
  1162.  
  1163. #define glRasterPos2f_jump(s, t) \
  1164.     LP2NR(0x3e4, glRasterPos2f, GLfloat, s, fp0, GLfloat, t, fp1, \
  1165.     , CYBERGL_BASE_NAME)
  1166. GLvoid glRasterPos2f(GLfloat s, GLfloat t) {
  1167.   glRasterPos2f_jump(s, t);
  1168. }
  1169.  
  1170. #define glRasterPos2fv_jump(v) \
  1171.     LP1NR(0x42c, glRasterPos2fv, const GLfloat *, v, a0, \
  1172.     , CYBERGL_BASE_NAME)
  1173. GLvoid glRasterPos2fv(const GLfloat *v) {
  1174.   glRasterPos2fv_jump(v);
  1175. }
  1176.  
  1177. #define glRasterPos2i_jump(s, t) \
  1178.     LP2NR(0x3de, glRasterPos2i, GLint, s, d0, GLint, t, d1, \
  1179.     , CYBERGL_BASE_NAME)
  1180. GLvoid glRasterPos2i(GLint s, GLint t) {
  1181.   glRasterPos2i_jump(s, t);
  1182. }
  1183.  
  1184. #define glRasterPos2iv_jump(v) \
  1185.     LP1NR(0x426, glRasterPos2iv, const GLint *, v, a0, \
  1186.     , CYBERGL_BASE_NAME)
  1187. GLvoid glRasterPos2iv(const GLint *v) {
  1188.   glRasterPos2iv_jump(v);
  1189. }
  1190.  
  1191. #define glRasterPos2s_jump(s, t) \
  1192.     LP2NR(0x3d8, glRasterPos2s, GLshort, s, d0, GLshort, t, d1, \
  1193.     , CYBERGL_BASE_NAME)
  1194. GLvoid glRasterPos2s(GLshort s, GLshort t) {
  1195.   glRasterPos2s_jump(s, t);
  1196. }
  1197.  
  1198. #define glRasterPos2sv_jump(v) \
  1199.     LP1NR(0x420, glRasterPos2sv, const GLshort *, v, a0, \
  1200.     , CYBERGL_BASE_NAME)
  1201. GLvoid glRasterPos2sv(const GLshort *v) {
  1202.   glRasterPos2sv_jump(v);
  1203. }
  1204.  
  1205. #define glRasterPos3d_jump(s, t, r) \
  1206.     LP3NR(0x402, glRasterPos3d, GLdouble, s, fp0, GLdouble, t, fp1, GLdouble, r, fp2, \
  1207.     , CYBERGL_BASE_NAME)
  1208. GLvoid glRasterPos3d(GLdouble s, GLdouble t, GLdouble r) {
  1209.   glRasterPos3d_jump(s, t, r);
  1210. }
  1211.  
  1212. #define glRasterPos3dv_jump(v) \
  1213.     LP1NR(0x44a, glRasterPos3dv, const GLdouble *, v, a0, \
  1214.     , CYBERGL_BASE_NAME)
  1215. GLvoid glRasterPos3dv(const GLdouble *v) {
  1216.   glRasterPos3dv_jump(v);
  1217. }
  1218.  
  1219. #define glRasterPos3f_jump(s, t, r) \
  1220.     LP3NR(0x3fc, glRasterPos3f, GLfloat, s, fp0, GLfloat, t, fp1, GLfloat, r, fp2, \
  1221.     , CYBERGL_BASE_NAME)
  1222. GLvoid glRasterPos3f(GLfloat s, GLfloat t, GLfloat r) {
  1223.   glRasterPos3f_jump(s, t, r);
  1224. }
  1225.  
  1226. #define glRasterPos3fv_jump(v) \
  1227.     LP1NR(0x444, glRasterPos3fv, const GLfloat *, v, a0, \
  1228.     , CYBERGL_BASE_NAME)
  1229. GLvoid glRasterPos3fv(const GLfloat *v) {
  1230.   glRasterPos3fv_jump(v);
  1231. }
  1232.  
  1233. #define glRasterPos3i_jump(s, t, r) \
  1234.     LP3NR(0x3f6, glRasterPos3i, GLint, s, d0, GLint, t, d1, GLint, r, d2, \
  1235.     , CYBERGL_BASE_NAME)
  1236. GLvoid glRasterPos3i(GLint s, GLint t, GLint r) {
  1237.   glRasterPos3i_jump(s, t, r);
  1238. }
  1239.  
  1240. #define glRasterPos3iv_jump(v) \
  1241.     LP1NR(0x43e, glRasterPos3iv, const GLint *, v, a0, \
  1242.     , CYBERGL_BASE_NAME)
  1243. GLvoid glRasterPos3iv(const GLint *v) {
  1244.   glRasterPos3iv_jump(v);
  1245. }
  1246.  
  1247. #define glRasterPos3s_jump(s, t, r) \
  1248.     LP3NR(0x3f0, glRasterPos3s, GLshort, s, d0, GLshort, t, d1, GLshort, r, d2, \
  1249.     , CYBERGL_BASE_NAME)
  1250. GLvoid glRasterPos3s(GLshort s, GLshort t, GLshort r) {
  1251.   glRasterPos3s_jump(s, t, r);
  1252. }
  1253.  
  1254. #define glRasterPos3sv_jump(v) \
  1255.     LP1NR(0x438, glRasterPos3sv, const GLshort *, v, a0, \
  1256.     , CYBERGL_BASE_NAME)
  1257. GLvoid glRasterPos3sv(const GLshort *v) {
  1258.   glRasterPos3sv_jump(v);
  1259. }
  1260.  
  1261. #define glRasterPos4d_jump(s, t, r, q) \
  1262.     LP4NR(0x41a, glRasterPos4d, GLdouble, s, fp0, GLdouble, t, fp1, GLdouble, r, fp2, GLdouble, q, fp3, \
  1263.     , CYBERGL_BASE_NAME)
  1264. GLvoid glRasterPos4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
  1265.   glRasterPos4d_jump(s, t, r, q);
  1266. }
  1267.  
  1268. #define glRasterPos4dv_jump(v) \
  1269.     LP1NR(0x462, glRasterPos4dv, const GLdouble *, v, a0, \
  1270.     , CYBERGL_BASE_NAME)
  1271. GLvoid glRasterPos4dv(const GLdouble *v) {
  1272.   glRasterPos4dv_jump(v);
  1273. }
  1274.  
  1275. #define glRasterPos4f_jump(s, t, r, q) \
  1276.     LP4NR(0x414, glRasterPos4f, GLfloat, s, fp0, GLfloat, t, fp1, GLfloat, r, fp2, GLfloat, q, fp3, \
  1277.     , CYBERGL_BASE_NAME)
  1278. GLvoid glRasterPos4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
  1279.   glRasterPos4f_jump(s, t, r, q);
  1280. }
  1281.  
  1282. #define glRasterPos4fv_jump(v) \
  1283.     LP1NR(0x45c, glRasterPos4fv, const GLfloat *, v, a0, \
  1284.     , CYBERGL_BASE_NAME)
  1285. GLvoid glRasterPos4fv(const GLfloat *v) {
  1286.   glRasterPos4fv_jump(v);
  1287. }
  1288.  
  1289. #define glRasterPos4i_jump(s, t, r, q) \
  1290.     LP4NR(0x40e, glRasterPos4i, GLint, s, d0, GLint, t, d1, GLint, r, d2, GLint, q, d3, \
  1291.     , CYBERGL_BASE_NAME)
  1292. GLvoid glRasterPos4i(GLint s, GLint t, GLint r, GLint q) {
  1293.   glRasterPos4i_jump(s, t, r, q);
  1294. }
  1295.  
  1296. #define glRasterPos4iv_jump(v) \
  1297.     LP1NR(0x456, glRasterPos4iv, const GLint *, v, a0, \
  1298.     , CYBERGL_BASE_NAME)
  1299. GLvoid glRasterPos4iv(const GLint *v) {
  1300.   glRasterPos4iv_jump(v);
  1301. }
  1302.  
  1303. #define glRasterPos4s_jump(s, t, r, q) \
  1304.     LP4NR(0x408, glRasterPos4s, GLshort, s, d0, GLshort, t, d1, GLshort, r, d2, GLshort, q, d3, \
  1305.     , CYBERGL_BASE_NAME)
  1306. GLvoid glRasterPos4s(GLshort s, GLshort t, GLshort r, GLshort q) {
  1307.   glRasterPos4s_jump(s, t, r, q);
  1308. }
  1309.  
  1310. #define glRasterPos4sv_jump(v) \
  1311.     LP1NR(0x450, glRasterPos4sv, const GLshort *, v, a0, \
  1312.     , CYBERGL_BASE_NAME)
  1313. GLvoid glRasterPos4sv(const GLshort *v) {
  1314.   glRasterPos4sv_jump(v);
  1315. }
  1316.  
  1317. #define glRectd_jump(x1, y1, x2, y2) \
  1318.     LP4NR(0x3ae, glRectd, GLdouble, x1, fp0, GLdouble, y1, fp1, GLdouble, x2, fp2, GLdouble, y2, fp3, \
  1319.     , CYBERGL_BASE_NAME)
  1320. GLvoid glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) {
  1321.   glRectd_jump(x1, y1, x2, y2);
  1322. }
  1323.  
  1324. #define glRectdv_jump(v1, v2) \
  1325.     LP2NR(0x3c6, glRectdv, const GLdouble *, v1, a0, const GLdouble *, v2, a1, \
  1326.     , CYBERGL_BASE_NAME)
  1327. GLvoid glRectdv(const GLdouble *v1, const GLdouble *v2) {
  1328.   glRectdv_jump(v1, v2);
  1329. }
  1330.  
  1331. #define glRectf_jump(x1, y1, x2, y2) \
  1332.     LP4NR(0x3a8, glRectf, GLfloat, x1, fp0, GLfloat, y1, fp1, GLfloat, x2, fp2, GLfloat, y2, fp3, \
  1333.     , CYBERGL_BASE_NAME)
  1334. GLvoid glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) {
  1335.   glRectf_jump(x1, y1, x2, y2);
  1336. }
  1337.  
  1338. #define glRectfv_jump(v1, v2) \
  1339.     LP2NR(0x3c0, glRectfv, const GLfloat *, v1, a0, const GLfloat *, v2, a1, \
  1340.     , CYBERGL_BASE_NAME)
  1341. GLvoid glRectfv(const GLfloat *v1, const GLfloat *v2) {
  1342.   glRectfv_jump(v1, v2);
  1343. }
  1344.  
  1345. #define glRecti_jump(x1, y1, x2, y2) \
  1346.     LP4NR(0x3a2, glRecti, GLint, x1, d0, GLint, y1, d1, GLint, x2, d2, GLint, y2, d3, \
  1347.     , CYBERGL_BASE_NAME)
  1348. GLvoid glRecti(GLint x1, GLint y1, GLint x2, GLint y2) {
  1349.   glRecti_jump(x1, y1, x2, y2);
  1350. }
  1351.  
  1352. #define glRectiv_jump(v1, v2) \
  1353.     LP2NR(0x3ba, glRectiv, const GLint *, v1, a0, const GLint *, v2, a1, \
  1354.     , CYBERGL_BASE_NAME)
  1355. GLvoid glRectiv(const GLint *v1, const GLint *v2) {
  1356.   glRectiv_jump(v1, v2);
  1357. }
  1358.  
  1359. #define glRects_jump(x1, y1, x2, y2) \
  1360.     LP4NR(0x39c, glRects, GLshort, x1, d0, GLshort, y1, d1, GLshort, x2, d2, GLshort, y2, d3, \
  1361.     , CYBERGL_BASE_NAME)
  1362. GLvoid glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) {
  1363.   glRects_jump(x1, y1, x2, y2);
  1364. }
  1365.  
  1366. #define glRectsv_jump(v1, v2) \
  1367.     LP2NR(0x3b4, glRectsv, const GLshort *, v1, a0, const GLshort *, v2, a1, \
  1368.     , CYBERGL_BASE_NAME)
  1369. GLvoid glRectsv(const GLshort *v1, const GLshort *v2) {
  1370.   glRectsv_jump(v1, v2);
  1371. }
  1372.  
  1373. #define glRenderMode_jump(mode) \
  1374.     LP1(0x564, GLint, glRenderMode, GLenum, mode, d0, \
  1375.     , CYBERGL_BASE_NAME)
  1376. GLint glRenderMode(GLenum mode) {
  1377.   return glRenderMode_jump(mode);
  1378. }
  1379.  
  1380. #define glRotated_jump(angle, x, y, z) \
  1381.     LP4NR(0x49e, glRotated, GLdouble, angle, fp0, GLdouble, x, fp1, GLdouble, y, fp2, GLdouble, z, fp3, \
  1382.     , CYBERGL_BASE_NAME)
  1383. GLvoid glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) {
  1384.   glRotated_jump(angle, x, y, z);
  1385. }
  1386.  
  1387. #define glRotatef_jump(angle, x, y, z) \
  1388.     LP4NR(0x498, glRotatef, GLfloat, angle, fp0, GLfloat, x, fp1, GLfloat, y, fp2, GLfloat, z, fp3, \
  1389.     , CYBERGL_BASE_NAME)
  1390. GLvoid glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
  1391.   glRotatef_jump(angle, x, y, z);
  1392. }
  1393.  
  1394. #define glScaled_jump(x, y, z) \
  1395.     LP3NR(0x4b6, glScaled, GLdouble, x, fp0, GLdouble, y, fp1, GLdouble, z, fp2, \
  1396.     , CYBERGL_BASE_NAME)
  1397. GLvoid glScaled(GLdouble x, GLdouble y, GLdouble z) {
  1398.   glScaled_jump(x, y, z);
  1399. }
  1400.  
  1401. #define glScalef_jump(x, y, z) \
  1402.     LP3NR(0x4b0, glScalef, GLfloat, x, fp0, GLfloat, y, fp1, GLfloat, z, fp2, \
  1403.     , CYBERGL_BASE_NAME)
  1404. GLvoid glScalef(GLfloat x, GLfloat y, GLfloat z) {
  1405.   glScalef_jump(x, y, z);
  1406. }
  1407.  
  1408. #define glSelectBuffer_jump(size, buffer) \
  1409.     LP2NR(0x582, glSelectBuffer, GLsizei, size, d0, GLuint *, buffer, a0, \
  1410.     , CYBERGL_BASE_NAME)
  1411. GLvoid glSelectBuffer(GLsizei size, GLuint *buffer) {
  1412.   glSelectBuffer_jump(size, buffer);
  1413. }
  1414.  
  1415. #define glShadeModel_jump(mode) \
  1416.     LP1NR(0x552, glShadeModel, GLenum, mode, d0, \
  1417.     , CYBERGL_BASE_NAME)
  1418. GLvoid glShadeModel(GLenum mode) {
  1419.   glShadeModel_jump(mode);
  1420. }
  1421.  
  1422. #define glTexCoord1d_jump(s) \
  1423.     LP1NR(0x1c2, glTexCoord1d, GLdouble, s, fp0, \
  1424.     , CYBERGL_BASE_NAME)
  1425. GLvoid glTexCoord1d(GLdouble s) {
  1426.   glTexCoord1d_jump(s);
  1427. }
  1428.  
  1429. #define glTexCoord1dv_jump(v) \
  1430.     LP1NR(0x222, glTexCoord1dv, const GLdouble *, v, a0, \
  1431.     , CYBERGL_BASE_NAME)
  1432. GLvoid glTexCoord1dv(const GLdouble *v) {
  1433.   glTexCoord1dv_jump(v);
  1434. }
  1435.  
  1436. #define glTexCoord1f_jump(s) \
  1437.     LP1NR(0x1bc, glTexCoord1f, GLfloat, s, fp0, \
  1438.     , CYBERGL_BASE_NAME)
  1439. GLvoid glTexCoord1f(GLfloat s) {
  1440.   glTexCoord1f_jump(s);
  1441. }
  1442.  
  1443. #define glTexCoord1fv_jump(v) \
  1444.     LP1NR(0x21c, glTexCoord1fv, const GLfloat *, v, a0, \
  1445.     , CYBERGL_BASE_NAME)
  1446. GLvoid glTexCoord1fv(const GLfloat *v) {
  1447.   glTexCoord1fv_jump(v);
  1448. }
  1449.  
  1450. #define glTexCoord1i_jump(s) \
  1451.     LP1NR(0x1b6, glTexCoord1i, GLint, s, d0, \
  1452.     , CYBERGL_BASE_NAME)
  1453. GLvoid glTexCoord1i(GLint s) {
  1454.   glTexCoord1i_jump(s);
  1455. }
  1456.  
  1457. #define glTexCoord1iv_jump(v) \
  1458.     LP1NR(0x216, glTexCoord1iv, const GLint *, v, a0, \
  1459.     , CYBERGL_BASE_NAME)
  1460. GLvoid glTexCoord1iv(const GLint *v) {
  1461.   glTexCoord1iv_jump(v);
  1462. }
  1463.  
  1464. #define glTexCoord1s_jump(s) \
  1465.     LP1NR(0x1b0, glTexCoord1s, GLshort, s, d0, \
  1466.     , CYBERGL_BASE_NAME)
  1467. GLvoid glTexCoord1s(GLshort s) {
  1468.   glTexCoord1s_jump(s);
  1469. }
  1470.  
  1471. #define glTexCoord1sv_jump(v) \
  1472.     LP1NR(0x210, glTexCoord1sv, const GLshort *, v, a0, \
  1473.     , CYBERGL_BASE_NAME)
  1474. GLvoid glTexCoord1sv(const GLshort *v) {
  1475.   glTexCoord1sv_jump(v);
  1476. }
  1477.  
  1478. #define glTexCoord2d_jump(s, t) \
  1479.     LP2NR(0x1da, glTexCoord2d, GLdouble, s, fp0, GLdouble, t, fp1, \
  1480.     , CYBERGL_BASE_NAME)
  1481. GLvoid glTexCoord2d(GLdouble s, GLdouble t) {
  1482.   glTexCoord2d_jump(s, t);
  1483. }
  1484.  
  1485. #define glTexCoord2dv_jump(v) \
  1486.     LP1NR(0x23a, glTexCoord2dv, const GLdouble *, v, a0, \
  1487.     , CYBERGL_BASE_NAME)
  1488. GLvoid glTexCoord2dv(const GLdouble *v) {
  1489.   glTexCoord2dv_jump(v);
  1490. }
  1491.  
  1492. #define glTexCoord2f_jump(s, t) \
  1493.     LP2NR(0x1d4, glTexCoord2f, GLfloat, s, fp0, GLfloat, t, fp1, \
  1494.     , CYBERGL_BASE_NAME)
  1495. GLvoid glTexCoord2f(GLfloat s, GLfloat t) {
  1496.   glTexCoord2f_jump(s, t);
  1497. }
  1498.  
  1499. #define glTexCoord2fv_jump(v) \
  1500.     LP1NR(0x234, glTexCoord2fv, const GLfloat *, v, a0, \
  1501.     , CYBERGL_BASE_NAME)
  1502. GLvoid glTexCoord2fv(const GLfloat *v) {
  1503.   glTexCoord2fv_jump(v);
  1504. }
  1505.  
  1506. #define glTexCoord2i_jump(s, t) \
  1507.     LP2NR(0x1ce, glTexCoord2i, GLint, s, d0, GLint, t, d1, \
  1508.     , CYBERGL_BASE_NAME)
  1509. GLvoid glTexCoord2i(GLint s, GLint t) {
  1510.   glTexCoord2i_jump(s, t);
  1511. }
  1512.  
  1513. #define glTexCoord2iv_jump(v) \
  1514.     LP1NR(0x22e, glTexCoord2iv, const GLint *, v, a0, \
  1515.     , CYBERGL_BASE_NAME)
  1516. GLvoid glTexCoord2iv(const GLint *v) {
  1517.   glTexCoord2iv_jump(v);
  1518. }
  1519.  
  1520. #define glTexCoord2s_jump(s, t) \
  1521.     LP2NR(0x1c8, glTexCoord2s, GLshort, s, d0, GLshort, t, d1, \
  1522.     , CYBERGL_BASE_NAME)
  1523. GLvoid glTexCoord2s(GLshort s, GLshort t) {
  1524.   glTexCoord2s_jump(s, t);
  1525. }
  1526.  
  1527. #define glTexCoord2sv_jump(v) \
  1528.     LP1NR(0x228, glTexCoord2sv, const GLshort *, v, a0, \
  1529.     , CYBERGL_BASE_NAME)
  1530. GLvoid glTexCoord2sv(const GLshort *v) {
  1531.   glTexCoord2sv_jump(v);
  1532. }
  1533.  
  1534. #define glTexCoord3d_jump(s, t, r) \
  1535.     LP3NR(0x1f2, glTexCoord3d, GLdouble, s, fp0, GLdouble, t, fp1, GLdouble, r, fp2, \
  1536.     , CYBERGL_BASE_NAME)
  1537. GLvoid glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) {
  1538.   glTexCoord3d_jump(s, t, r);
  1539. }
  1540.  
  1541. #define glTexCoord3dv_jump(v) \
  1542.     LP1NR(0x252, glTexCoord3dv, const GLdouble *, v, a0, \
  1543.     , CYBERGL_BASE_NAME)
  1544. GLvoid glTexCoord3dv(const GLdouble *v) {
  1545.   glTexCoord3dv_jump(v);
  1546. }
  1547.  
  1548. #define glTexCoord3f_jump(s, t, r) \
  1549.     LP3NR(0x1ec, glTexCoord3f, GLfloat, s, fp0, GLfloat, t, fp1, GLfloat, r, fp2, \
  1550.     , CYBERGL_BASE_NAME)
  1551. GLvoid glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {
  1552.   glTexCoord3f_jump(s, t, r);
  1553. }
  1554.  
  1555. #define glTexCoord3fv_jump(v) \
  1556.     LP1NR(0x24c, glTexCoord3fv, const GLfloat *, v, a0, \
  1557.     , CYBERGL_BASE_NAME)
  1558. GLvoid glTexCoord3fv(const GLfloat *v) {
  1559.   glTexCoord3fv_jump(v);
  1560. }
  1561.  
  1562. #define glTexCoord3i_jump(s, t, r) \
  1563.     LP3NR(0x1e6, glTexCoord3i, GLint, s, d0, GLint, t, d1, GLint, r, d2, \
  1564.     , CYBERGL_BASE_NAME)
  1565. GLvoid glTexCoord3i(GLint s, GLint t, GLint r) {
  1566.   glTexCoord3i_jump(s, t, r);
  1567. }
  1568.  
  1569. #define glTexCoord3iv_jump(v) \
  1570.     LP1NR(0x246, glTexCoord3iv, const GLint *, v, a0, \
  1571.     , CYBERGL_BASE_NAME)
  1572. GLvoid glTexCoord3iv(const GLint *v) {
  1573.   glTexCoord3iv_jump(v);
  1574. }
  1575.  
  1576. #define glTexCoord3s_jump(s, t, r) \
  1577.     LP3NR(0x1e0, glTexCoord3s, GLshort, s, d0, GLshort, t, d1, GLshort, r, d2, \
  1578.     , CYBERGL_BASE_NAME)
  1579. GLvoid glTexCoord3s(GLshort s, GLshort t, GLshort r) {
  1580.   glTexCoord3s_jump(s, t, r);
  1581. }
  1582.  
  1583. #define glTexCoord3sv_jump(v) \
  1584.     LP1NR(0x240, glTexCoord3sv, const GLshort *, v, a0, \
  1585.     , CYBERGL_BASE_NAME)
  1586. GLvoid glTexCoord3sv(const GLshort *v) {
  1587.   glTexCoord3sv_jump(v);
  1588. }
  1589.  
  1590. #define glTexCoord4d_jump(s, t, r, q) \
  1591.     LP4NR(0x20a, glTexCoord4d, GLdouble, s, fp0, GLdouble, t, fp1, GLdouble, r, fp2, GLdouble, q, fp3, \
  1592.     , CYBERGL_BASE_NAME)
  1593. GLvoid glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) {
  1594.   glTexCoord4d_jump(s, t, r, q);
  1595. }
  1596.  
  1597. #define glTexCoord4dv_jump(v) \
  1598.     LP1NR(0x26a, glTexCoord4dv, const GLdouble *, v, a0, \
  1599.     , CYBERGL_BASE_NAME)
  1600. GLvoid glTexCoord4dv(const GLdouble *v) {
  1601.   glTexCoord4dv_jump(v);
  1602. }
  1603.  
  1604. #define glTexCoord4f_jump(s, t, r, q) \
  1605.     LP4NR(0x204, glTexCoord4f, GLfloat, s, fp0, GLfloat, t, fp1, GLfloat, r, fp2, GLfloat, q, fp3, \
  1606.     , CYBERGL_BASE_NAME)
  1607. GLvoid glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
  1608.   glTexCoord4f_jump(s, t, r, q);
  1609. }
  1610.  
  1611. #define glTexCoord4fv_jump(v) \
  1612.     LP1NR(0x264, glTexCoord4fv, const GLfloat *, v, a0, \
  1613.     , CYBERGL_BASE_NAME)
  1614. GLvoid glTexCoord4fv(const GLfloat *v) {
  1615.   glTexCoord4fv_jump(v);
  1616. }
  1617.  
  1618. #define glTexCoord4i_jump(s, t, r, q) \
  1619.     LP4NR(0x1fe, glTexCoord4i, GLint, s, d0, GLint, t, d1, GLint, r, d2, GLint, q, d3, \
  1620.     , CYBERGL_BASE_NAME)
  1621. GLvoid glTexCoord4i(GLint s, GLint t, GLint r, GLint q) {
  1622.   glTexCoord4i_jump(s, t, r, q);
  1623. }
  1624.  
  1625. #define glTexCoord4iv_jump(v) \
  1626.     LP1NR(0x25e, glTexCoord4iv, const GLint *, v, a0, \
  1627.     , CYBERGL_BASE_NAME)
  1628. GLvoid glTexCoord4iv(const GLint *v) {
  1629.   glTexCoord4iv_jump(v);
  1630. }
  1631.  
  1632. #define glTexCoord4s_jump(s, t, r, q) \
  1633.     LP4NR(0x1f8, glTexCoord4s, GLshort, s, d0, GLshort, t, d1, GLshort, r, d2, GLshort, q, d3, \
  1634.     , CYBERGL_BASE_NAME)
  1635. GLvoid glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) {
  1636.   glTexCoord4s_jump(s, t, r, q);
  1637. }
  1638.  
  1639. #define glTexCoord4sv_jump(v) \
  1640.     LP1NR(0x258, glTexCoord4sv, const GLshort *, v, a0, \
  1641.     , CYBERGL_BASE_NAME)
  1642. GLvoid glTexCoord4sv(const GLshort *v) {
  1643.   glTexCoord4sv_jump(v);
  1644. }
  1645.  
  1646. #define glTexEnvf_jump(target, pname, param) \
  1647.     LP3NR(0x5fa, glTexEnvf, GLenum, target, d0, GLenum, pname, d1, GLfloat, param, fp0, \
  1648.     , CYBERGL_BASE_NAME)
  1649. GLvoid glTexEnvf(GLenum target, GLenum pname, GLfloat param) {
  1650.   glTexEnvf_jump(target, pname, param);
  1651. }
  1652.  
  1653. #define glTexEnvfv_jump(target, pname, params) \
  1654.     LP3NR(0x606, glTexEnvfv, GLenum, target, d0, GLenum, pname, d1, const GLfloat *, params, a0, \
  1655.     , CYBERGL_BASE_NAME)
  1656. GLvoid glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {
  1657.   glTexEnvfv_jump(target, pname, params);
  1658. }
  1659.  
  1660. #define glTexEnvi_jump(target, pname, param) \
  1661.     LP3NR(0x600, glTexEnvi, GLenum, target, d0, GLenum, pname, d1, GLint, param, d2, \
  1662.     , CYBERGL_BASE_NAME)
  1663. GLvoid glTexEnvi(GLenum target, GLenum pname, GLint param) {
  1664.   glTexEnvi_jump(target, pname, param);
  1665. }
  1666.  
  1667. #define glTexEnviv_jump(target, pname, params) \
  1668.     LP3NR(0x60c, glTexEnviv, GLenum, target, d0, GLenum, pname, d1, const GLint *, params, a0, \
  1669.     , CYBERGL_BASE_NAME)
  1670. GLvoid glTexEnviv(GLenum target, GLenum pname, const GLint *params) {
  1671.   glTexEnviv_jump(target, pname, params);
  1672. }
  1673.  
  1674. #define glTexGend_jump(coord, pname, param) \
  1675.     LP3NR(0x5e2, glTexGend, GLenum, coord, d0, GLenum, pname, d1, GLdouble, param, fp0, \
  1676.     , CYBERGL_BASE_NAME)
  1677. GLvoid glTexGend(GLenum coord, GLenum pname, GLdouble param) {
  1678.   glTexGend_jump(coord, pname, param);
  1679. }
  1680.  
  1681. #define glTexGendv_jump(coord, pname, params) \
  1682.     LP3NR(0x5f4, glTexGendv, GLenum, coord, d0, GLenum, pname, d1, const GLdouble *, params, a0, \
  1683.     , CYBERGL_BASE_NAME)
  1684. GLvoid glTexGendv(GLenum coord, GLenum pname, const GLdouble *params) {
  1685.   glTexGendv_jump(coord, pname, params);
  1686. }
  1687.  
  1688. #define glTexGenf_jump(coord, pname, param) \
  1689.     LP3NR(0x5dc, glTexGenf, GLenum, coord, d0, GLenum, pname, d1, GLfloat, param, fp0, \
  1690.     , CYBERGL_BASE_NAME)
  1691. GLvoid glTexGenf(GLenum coord, GLenum pname, GLfloat param) {
  1692.   glTexGenf_jump(coord, pname, param);
  1693. }
  1694.  
  1695. #define glTexGenfv_jump(coord, pname, params) \
  1696.     LP3NR(0x5ee, glTexGenfv, GLenum, coord, d0, GLenum, pname, d1, const GLfloat *, params, a0, \
  1697.     , CYBERGL_BASE_NAME)
  1698. GLvoid glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) {
  1699.   glTexGenfv_jump(coord, pname, params);
  1700. }
  1701.  
  1702. #define glTexGeni_jump(coord, pname, param) \
  1703.     LP3NR(0x5d6, glTexGeni, GLenum, coord, d0, GLenum, pname, d1, GLint, param, d0, \
  1704.     , CYBERGL_BASE_NAME)
  1705. GLvoid glTexGeni(GLenum coord, GLenum pname, GLint param) {
  1706.   glTexGeni_jump(coord, pname, param);
  1707. }
  1708.  
  1709. #define glTexGeniv_jump(coord, pname, params) \
  1710.     LP3NR(0x5e8, glTexGeniv, GLenum, coord, d0, GLenum, pname, d1, const GLint *, params, a0, \
  1711.     , CYBERGL_BASE_NAME)
  1712. GLvoid glTexGeniv(GLenum coord, GLenum pname, const GLint *params) {
  1713.   glTexGeniv_jump(coord, pname, params);
  1714. }
  1715.  
  1716. #define glTexImage1D_jump(target, level, components, width, border, format, type, pixels) \
  1717.     LP8NR(0x62a, glTexImage1D, GLenum, target, d0, GLint, level, d1, GLint, components, d2, GLsizei, width, d3, GLint, border, d4, GLenum, format, d5, GLenum, type, d6, const GLvoid *, pixels, a0, \
  1718.     , CYBERGL_BASE_NAME)
  1719. GLvoid glTexImage1D(GLenum target, GLint level, GLint components, GLsizei width,
  1720.                   GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
  1721.   glTexImage1D_jump(target, level, components, width, border, format, type, pixels);
  1722. }
  1723.  
  1724. #define glTexImage2D_jump(target, level, components, width, height, border, format, type, pixels) \
  1725.     LP9NR(0x630, glTexImage2D, GLenum, target, d0, GLint, level, d1, GLint, components, d2, GLsizei, width, d3, GLsizei, height, d4, GLint, border, d5, GLenum, format, d6, GLenum, type, d7, const GLvoid *, pixels, a0, \
  1726.     , CYBERGL_BASE_NAME)
  1727. GLvoid glTexImage2D(GLenum target, GLint level, GLint components, GLsizei width, GLsizei height,
  1728.                   GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
  1729.   glTexImage2D_jump(target, level, components, width, height, border, format, type, pixels);
  1730. }
  1731.  
  1732. #define glTexParameterf_jump(target, pname, param) \
  1733.     LP3NR(0x612, glTexParameterf, GLenum, target, d0, GLenum, pname, d1, GLfloat, param, fp0, \
  1734.     , CYBERGL_BASE_NAME)
  1735. GLvoid glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
  1736.   glTexParameterf_jump(target, pname, param);
  1737. }
  1738.  
  1739. #define glTexParameterfv_jump(target, pname, params) \
  1740.     LP3NR(0x61e, glTexParameterfv, GLenum, target, d0, GLenum, pname, d1, const GLfloat *, params, a0, \
  1741.     , CYBERGL_BASE_NAME)
  1742. GLvoid glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) {
  1743.   glTexParameterfv_jump(target, pname, params);
  1744. }
  1745.  
  1746. #define glTexParameteri_jump(target, pname, param) \
  1747.     LP3NR(0x618, glTexParameteri, GLenum, target, d0, GLenum, pname, d1, GLint, param, d2, \
  1748.     , CYBERGL_BASE_NAME)
  1749. GLvoid glTexParameteri(GLenum target, GLenum pname, GLint param) {
  1750.   glTexParameteri_jump(target, pname, param);
  1751. }
  1752.  
  1753. #define glTexParameteriv_jump(target, pname, params) \
  1754.     LP3NR(0x624, glTexParameteriv, GLenum, target, d0, GLenum, pname, d1, const GLint *, params, a0, \
  1755.     , CYBERGL_BASE_NAME)
  1756. GLvoid glTexParameteriv(GLenum target, GLenum pname, const GLint *params) {
  1757.   glTexParameteriv_jump(target, pname, params);
  1758. }
  1759.  
  1760. #define glTranslated_jump(x, y, z) \
  1761.     LP3NR(0x4aa, glTranslated, GLdouble, x, fp0, GLdouble, y, fp1, GLdouble, z, fp2, \
  1762.     , CYBERGL_BASE_NAME)
  1763. GLvoid glTranslated(GLdouble x, GLdouble y, GLdouble z) {
  1764.   glTranslated_jump(x, y, z);
  1765. }
  1766.  
  1767. #define glTranslatef_jump(x, y, z) \
  1768.     LP3NR(0x4a4, glTranslatef, GLfloat, x, fp0, GLfloat, y, fp1, GLfloat, z, fp2, \
  1769.     , CYBERGL_BASE_NAME)
  1770. GLvoid glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
  1771.   glTranslatef_jump(x, y, z);
  1772. }
  1773.  
  1774. /*
  1775.  * probably wrong
  1776.  */
  1777. #define glUnProject_jump(winx, winy, winz, objx, objy, objz) \
  1778.     LP6(0x4e0, GLboolean, glUnProject, GLdouble, winx, fp0, GLdouble, winy, fp1, GLdouble, winz, fp2, GLdouble *, objx, a0, GLdouble *, objy, a1, GLdouble *, objz, a2, \
  1779.     , CYBERGL_BASE_NAME)
  1780. GLboolean glUnProject(GLdouble winx, GLdouble winy, GLdouble winz, GLdouble *objx, GLdouble *objy, GLdouble *objz) {
  1781.   return glUnProject_jump(winx, winy, winz, objx, objy, objz);
  1782. }
  1783.  
  1784. #define glVertex2d_jump(x, y) \
  1785.     LP2NR(0x132, glVertex2d, GLdouble, x, fp0, GLdouble, y, fp1, \
  1786.     , CYBERGL_BASE_NAME)
  1787. GLvoid glVertex2d(GLdouble x, GLdouble y) {
  1788.   glVertex2d_jump(x, y);
  1789. }
  1790.  
  1791. #define glVertex2dv_jump(v) \
  1792.     LP1NR(0x17a, glVertex2dv, const GLdouble *, v, a0, \
  1793.     , CYBERGL_BASE_NAME)
  1794. GLvoid glVertex2dv(const GLdouble *v) {
  1795.   glVertex2dv_jump(v);
  1796. }
  1797.  
  1798. #define glVertex2f_jump(x, y) \
  1799.     LP2NR(0x12c, glVertex2f, GLfloat, x, fp0, GLfloat, y, fp1, \
  1800.     , CYBERGL_BASE_NAME)
  1801. GLvoid glVertex2f(GLfloat x, GLfloat y) {
  1802.   glVertex2f_jump(x, y);
  1803. }
  1804.  
  1805. #define glVertex2fv_jump(v) \
  1806.     LP1NR(0x174, glVertex2fv, const GLfloat *, v, a0, \
  1807.     , CYBERGL_BASE_NAME)
  1808. GLvoid glVertex2fv(const GLfloat *v) {
  1809.   glVertex2fv_jump(v);
  1810. }
  1811.  
  1812. #define glVertex2i_jump(x, y) \
  1813.     LP2NR(0x126, glVertex2i, GLint, x, d0, GLint, y, d1, \
  1814.     , CYBERGL_BASE_NAME)
  1815. GLvoid glVertex2i(GLint x, GLint y) {
  1816.   glVertex2i_jump(x, y);
  1817. }
  1818.  
  1819. #define glVertex2iv_jump(v) \
  1820.     LP1NR(0x16e, glVertex2iv, const GLint *, v, a0, \
  1821.     , CYBERGL_BASE_NAME)
  1822. GLvoid glVertex2iv(const GLint *v) {
  1823.   glVertex2iv_jump(v);
  1824. }
  1825.  
  1826. #define glVertex2s_jump(x, y) \
  1827.     LP2NR(0x120, glVertex2s, GLshort, x, d0, GLshort, y, d1, \
  1828.     , CYBERGL_BASE_NAME)
  1829. GLvoid glVertex2s(GLshort x, GLshort y) {
  1830.   glVertex2s_jump(x, y);
  1831. }
  1832.  
  1833. #define glVertex2sv_jump(v) \
  1834.     LP1NR(0x168, glVertex2sv, const GLshort *, v, a0, \
  1835.     , CYBERGL_BASE_NAME)
  1836. GLvoid glVertex2sv(const GLshort *v) {
  1837.   glVertex2sv_jump(v);
  1838. }
  1839.  
  1840. #define glVertex3d_jump(x, y, z) \
  1841.     LP3NR(0x14a, glVertex3d, GLdouble, x, fp0, GLdouble, y, fp1, GLdouble, z, fp2, \
  1842.     , CYBERGL_BASE_NAME)
  1843. GLvoid glVertex3d(GLdouble x, GLdouble y, GLdouble z) {
  1844.   glVertex3d_jump(x, y, z);
  1845. }
  1846.  
  1847. #define glVertex3dv_jump(v) \
  1848.     LP1NR(0x192, glVertex3dv, const GLdouble *, v, a0, \
  1849.     , CYBERGL_BASE_NAME)
  1850. GLvoid glVertex3dv(const GLdouble *v) {
  1851.   glVertex3dv_jump(v);
  1852. }
  1853.  
  1854. #define glVertex3f_jump(x, y, z) \
  1855.     LP3NR(0x144, glVertex3f, GLfloat, x, fp0, GLfloat, y, fp1, GLfloat, z, fp2, \
  1856.     , CYBERGL_BASE_NAME)
  1857. GLvoid glVertex3f(GLfloat x, GLfloat y, GLfloat z) {
  1858.   glVertex3f_jump(x, y, z);
  1859. }
  1860.  
  1861. #define glVertex3fv_jump(v) \
  1862.     LP1NR(0x18c, glVertex3fv, const GLfloat *, v, a0, \
  1863.     , CYBERGL_BASE_NAME)
  1864. GLvoid glVertex3fv(const GLfloat *v) {
  1865.   glVertex3fv_jump(v);
  1866. }
  1867.  
  1868. #define glVertex3i_jump(x, y, z) \
  1869.     LP3NR(0x13e, glVertex3i, GLint, x, d0, GLint, y, d1, GLint, z, d2, \
  1870.     , CYBERGL_BASE_NAME)
  1871. GLvoid glVertex3i(GLint x, GLint y, GLint z) {
  1872.   glVertex3i_jump(x, y, z);
  1873. }
  1874.  
  1875. #define glVertex3iv_jump(v) \
  1876.     LP1NR(0x186, glVertex3iv, const GLint *, v, a0, \
  1877.     , CYBERGL_BASE_NAME)
  1878. GLvoid glVertex3iv(const GLint *v) {
  1879.   glVertex3iv_jump(v);
  1880. }
  1881.  
  1882. #define glVertex3s_jump(x, y, z) \
  1883.     LP3NR(0x138, glVertex3s, GLshort, x, d0, GLshort, y, d1, GLshort, z, d2, \
  1884.     , CYBERGL_BASE_NAME)
  1885. GLvoid glVertex3s(GLshort x, GLshort y, GLshort z) {
  1886.   glVertex3s_jump(x, y, z);
  1887. }
  1888.  
  1889. #define glVertex3sv_jump(v) \
  1890.     LP1NR(0x180, glVertex3sv, const GLshort *, v, a0, \
  1891.     , CYBERGL_BASE_NAME)
  1892. GLvoid glVertex3sv(const GLshort *v) {
  1893.   glVertex3sv_jump(v);
  1894. }
  1895.  
  1896. #define glVertex4d_jump(x, y, z, w) \
  1897.     LP4NR(0x162, glVertex4d, GLdouble, x, fp0, GLdouble, y, fp1, GLdouble, z, fp2, GLdouble, w, fp3, \
  1898.     , CYBERGL_BASE_NAME)
  1899. GLvoid glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
  1900.   glVertex4d_jump(x, y, z, w);
  1901. }
  1902.  
  1903. #define glVertex4dv_jump(v) \
  1904.     LP1NR(0x1aa, glVertex4dv, const GLdouble *, v, a0, \
  1905.     , CYBERGL_BASE_NAME)
  1906. GLvoid glVertex4dv(const GLdouble *v) {
  1907.   glVertex4dv_jump(v);
  1908. }
  1909.  
  1910. #define glVertex4f_jump(x, y, z, w) \
  1911.     LP4NR(0x15c, glVertex4f, GLfloat, x, fp0, GLfloat, y, fp1, GLfloat, z, fp2, GLfloat, w, fp3, \
  1912.     , CYBERGL_BASE_NAME)
  1913. GLvoid glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
  1914.   glVertex4f_jump(x, y, z, w);
  1915. }
  1916.  
  1917. #define glVertex4fv_jump(v) \
  1918.     LP1NR(0x1a4, glVertex4fv, const GLfloat *, v, a0, \
  1919.     , CYBERGL_BASE_NAME)
  1920. GLvoid glVertex4fv(const GLfloat *v) {
  1921.   glVertex4fv_jump(v);
  1922. }
  1923.  
  1924. #define glVertex4i_jump(x, y, z, w) \
  1925.     LP4NR(0x156, glVertex4i, GLint, x, d0, GLint, y, d1, GLint, z, d2, GLint, w, d3, \
  1926.     , CYBERGL_BASE_NAME)
  1927. GLvoid glVertex4i(GLint x, GLint y, GLint z, GLint w) {
  1928.   glVertex4i_jump(x, y, z, w);
  1929. }
  1930.  
  1931. #define glVertex4iv_jump(v) \
  1932.     LP1NR(0x19e, glVertex4iv, const GLint *, v, a0, \
  1933.     , CYBERGL_BASE_NAME)
  1934. GLvoid glVertex4iv(const GLint *v) {
  1935.   glVertex4iv_jump(v);
  1936. }
  1937.  
  1938. #define glVertex4s_jump(x, y, z, w) \
  1939.     LP4NR(0x150, glVertex4s, GLshort, x, d0, GLshort, y, d1, GLshort, z, d2, GLshort, w, d3, \
  1940.     , CYBERGL_BASE_NAME)
  1941. GLvoid glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) {
  1942.   glVertex4s_jump(x, y, z, w);
  1943. }
  1944.  
  1945. #define glVertex4sv_jump(v) \
  1946.     LP1NR(0x198, glVertex4sv, const GLshort *, v, a0, \
  1947.     , CYBERGL_BASE_NAME)
  1948. GLvoid glVertex4sv(const GLshort *v) {
  1949.   glVertex4sv_jump(v);
  1950. }
  1951.  
  1952. #define glViewport_jump(x, y, width, height) \
  1953.     LP4NR(0x46e, glViewport, GLint, x, d0, GLint, y, d1, GLsizei, width, d2, GLsizei, height, d3, \
  1954.     , CYBERGL_BASE_NAME)
  1955. GLvoid glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
  1956.   glViewport_jump(x, y, width, height);
  1957. }
  1958.  
  1959. #define openGLWindowTagList_jump(width, height, tags) \
  1960.     LP3(0x1e, GLvoid *, openGLWindowTagList, GLint, width, d0, GLint, height, d1, struct TagItem *, tags, a0, \
  1961.     , CYBERGL_BASE_NAME)
  1962. GLvoid *openGLWindowTagList(GLint width, GLint height, struct TagItem *tags) {
  1963.   return openGLWindowTagList_jump(width, height, tags);
  1964. }
  1965.  
  1966. #ifndef NO_INLINE_STDARG
  1967. #define openGLWindowTags(a0, a1, tags...) \
  1968.     ({ULONG _tags[] = { tags }; openGLWindowTagList((a0), (a1), (struct TagItem *)_tags);})
  1969. #endif /* !NO_INLINE_STDARG */
  1970.  
  1971. #define resizeGLWindow_jump(window, width, height) \
  1972.     LP3NR(0x36, resizeGLWindow, GLvoid *, window, a0, GLint, width, d0, GLint, height, d1, \
  1973.     , CYBERGL_BASE_NAME)
  1974. GLvoid resizeGLWindow(GLvoid *window, GLint width, GLint height) {
  1975.   resizeGLWindow_jump(window, width, height);
  1976. }
  1977.  
  1978.  
  1979.  
  1980. #endif /* !_LIB_CYBERGL_H */
  1981.