home *** CD-ROM | disk | FTP | other *** search
/ Dream 57 / Amiga_Dream_57.iso / Amiga / Programmation / c / Exemples / Affichage / CyberGL-DevKit.lha / include / inline / cybergl.h
Encoding:
C/C++ Source or Header  |  1998-05-18  |  36.3 KB  |  1,154 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _INLINE_CYBERGL_H
  4. #define _INLINE_CYBERGL_H
  5.  
  6. #ifndef __INLINE_MACROS_H
  7. #include <inline/macros.h>
  8. #endif /* !__INLINE_MACROS_H */
  9.  
  10. #ifndef CYBERGL_BASE_NAME
  11. #define CYBERGL_BASE_NAME CyberGLBase
  12. #endif /* !CYBERGL_BASE_NAME */
  13.  
  14. #define allocColor(window, r, g, b) \
  15.     LP4(0x42, GLubyte, allocColor, void *, window, a0, GLubyte, r, d0, GLubyte, g, d1, GLubyte, b, d2, \
  16.     , CYBERGL_BASE_NAME)
  17.  
  18. #define allocColorRange(window, r1, g1, b1, r2, g2, b2, num) \
  19.     LP8(0x48, GLubyte, allocColorRange, void *, window, a0, GLubyte, r1, d0, GLubyte, g1, d1, GLubyte, b1, d2, GLubyte, r2, d3, GLubyte, g2, d4, GLubyte, b2, d5, GLubyte, num, d6, \
  20.     , CYBERGL_BASE_NAME)
  21.  
  22. #define attachGLWindowTagList(wnd, width, height, tags) \
  23.     LP4(0x2a, void *, attachGLWindowTagList, struct Window *, wnd, a0, GLint, width, d0, GLint, height, d1, struct TagItem *, tags, a1, \
  24.     , CYBERGL_BASE_NAME)
  25.  
  26. #ifndef NO_INLINE_STDARG
  27. #define attachGLWindowTags(a0, a1, a2, tags...) \
  28.     ({ULONG _tags[] = { tags }; attachGLWindowTagList((a0), (a1), (a2), (struct TagItem *)_tags);})
  29. #endif /* !NO_INLINE_STDARG */
  30.  
  31. #define attachGLWndToRPTagList(scr, rp, width, height, tags) \
  32.     LP5(0x4e, void *, attachGLWndToRPTagList, struct Screen *, scr, a0, struct RastPort *, rp, a1, GLint, width, d0, GLint, height, d1, struct TagItem *, tags, a2, \
  33.     , CYBERGL_BASE_NAME)
  34.  
  35. #ifndef NO_INLINE_STDARG
  36. #define attachGLWndToRPTags(a0, a1, a2, a3, tags...) \
  37.     ({ULONG _tags[] = { tags }; attachGLWndToRPTagList((a0), (a1), (a2), (a3), (struct TagItem *)_tags);})
  38. #endif /* !NO_INLINE_STDARG */
  39.  
  40. #define closeGLWindow(window) \
  41.     LP1NR(0x24, closeGLWindow, void *, window, a0, \
  42.     , CYBERGL_BASE_NAME)
  43.  
  44. #define disposeGLWindow(window) \
  45.     LP1NR(0x30, disposeGLWindow, void *, window, a0, \
  46.     , CYBERGL_BASE_NAME)
  47.  
  48. #define getWindow(window) \
  49.     LP1(0x3c, struct Window *, getWindow, void *, window, a0, \
  50.     , CYBERGL_BASE_NAME)
  51.  
  52. #define glBegin(mode) \
  53.     LP1NR(0x114, glBegin, GLenum, mode, d0, \
  54.     , CYBERGL_BASE_NAME)
  55.  
  56. #define glBitmap_jump(bitmap) \
  57.     LP1NR(0x66c, glBitmap, const GLbitmap *, bitmap, a0, \
  58.     , CYBERGL_BASE_NAME)
  59. extern __inline GLvoid glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig,
  60.                                 GLfloat xmove, GLfloat ymove, GLubyte *bitmap) {
  61.   GLbitmap sbitmap;
  62.   
  63.   sbitmap.width = width;
  64.   sbitmap.height = height;
  65.   sbitmap.xorig = xorig;
  66.   sbitmap.xmove = xmove;
  67.   sbitmap.ymove = ymove;
  68.   sbitmap.bitmap = bitmap;
  69.   
  70.   glBitmap_jump(&sbitmap);
  71. }
  72.  
  73. #define glClear(mask) \
  74.     LP1NR(0x4fe, glClear, GLbitfield, mask, d0, \
  75.     , CYBERGL_BASE_NAME)
  76.  
  77. #define glClearColor(red, green, blue, alpha) \
  78.     LP4NR(0x504, glClearColor, GLclampf, red, fp0, GLclampf, green, fp1, GLclampf, blue, fp2, GLclampf, alpha, fp3, \
  79.     , CYBERGL_BASE_NAME)
  80.  
  81. #define glClearDepth(depth) \
  82.     LP1NR(0x510, glClearDepth, GLclampd, depth, fp0, \
  83.     , CYBERGL_BASE_NAME)
  84.  
  85. #define glClearIndex(index) \
  86.     LP1NR(0x50a, glClearIndex, GLfloat, index, fp0, \
  87.     , CYBERGL_BASE_NAME)
  88.  
  89. #define glClipPlane(plane, equation) \
  90.     LP2NR(0x4f8, glClipPlane, GLenum, plane, d0, const GLdouble *, equation, a0, \
  91.     , CYBERGL_BASE_NAME)
  92.  
  93. #define glColor3b(red, green, blue) \
  94.     LP3NR(0x2ac, glColor3b, GLbyte, red, d0, GLbyte, green, d1, GLbyte, blue, d2, \
  95.     , CYBERGL_BASE_NAME)
  96.  
  97. #define glColor3bv(v) \
  98.     LP1NR(0x30c, glColor3bv, const GLbyte *, v, a0, \
  99.     , CYBERGL_BASE_NAME)
  100.  
  101. #define glColor3d(red, green, blue) \
  102.     LP3NR(0x2c4, glColor3d, GLdouble, red, fp0, GLdouble, green, fp1, GLdouble, blue, fp2, \
  103.     , CYBERGL_BASE_NAME)
  104.  
  105. #define glColor3dv(v) \
  106.     LP1NR(0x324, glColor3dv, const GLdouble *, v, a0, \
  107.     , CYBERGL_BASE_NAME)
  108.  
  109. #define glColor3f(red, green, blue) \
  110.     LP3NR(0x2be, glColor3f, GLfloat, red, fp0, GLfloat, green, fp1, GLfloat, blue, fp2, \
  111.     , CYBERGL_BASE_NAME)
  112.  
  113. #define glColor3fv(v) \
  114.     LP1NR(0x31e, glColor3fv, const GLfloat *, v, a0, \
  115.     , CYBERGL_BASE_NAME)
  116.  
  117. #define glColor3i(red, green, blue) \
  118.     LP3NR(0x2b8, glColor3i, GLint, red, d0, GLint, green, d1, GLint, blue, d2, \
  119.     , CYBERGL_BASE_NAME)
  120.  
  121. #define glColor3iv(v) \
  122.     LP1NR(0x318, glColor3iv, const GLint *, v, a0, \
  123.     , CYBERGL_BASE_NAME)
  124.  
  125. #define glColor3s(red, green, blue) \
  126.     LP3NR(0x2b2, glColor3s, GLshort, red, d0, GLshort, green, d1, GLshort, blue, d2, \
  127.     , CYBERGL_BASE_NAME)
  128.  
  129. #define glColor3sv(v) \
  130.     LP1NR(0x312, glColor3sv, const GLshort *, v, a0, \
  131.     , CYBERGL_BASE_NAME)
  132.  
  133. #define glColor3ub(red, green, blue) \
  134.     LP3NR(0x2ca, glColor3ub, GLubyte, red, d0, GLubyte, green, d1, GLubyte, blue, d2, \
  135.     , CYBERGL_BASE_NAME)
  136.  
  137. #define glColor3ubv(v) \
  138.     LP1NR(0x32a, glColor3ubv, const GLubyte *, v, a0, \
  139.     , CYBERGL_BASE_NAME)
  140.  
  141. #define glColor3ui(red, green, blue) \
  142.     LP3NR(0x2d6, glColor3ui, GLuint, red, d0, GLuint, green, d1, GLuint, blue, d2, \
  143.     , CYBERGL_BASE_NAME)
  144.  
  145. #define glColor3uiv(v) \
  146.     LP1NR(0x336, glColor3uiv, const GLuint *, v, a0, \
  147.     , CYBERGL_BASE_NAME)
  148.  
  149. #define glColor3us(red, green, blue) \
  150.     LP3NR(0x2d0, glColor3us, GLushort, red, d0, GLushort, green, d1, GLushort, blue, d2, \
  151.     , CYBERGL_BASE_NAME)
  152.  
  153. #define glColor3usv(v) \
  154.     LP1NR(0x330, glColor3usv, const GLushort *, v, a0, \
  155.     , CYBERGL_BASE_NAME)
  156.  
  157. #define glColor4b(red, green, blue, alpha) \
  158.     LP4NR(0x2dc, glColor4b, GLbyte, red, d0, GLbyte, green, d1, GLbyte, blue, d2, GLbyte, alpha, d3, \
  159.     , CYBERGL_BASE_NAME)
  160.  
  161. #define glColor4bv(v) \
  162.     LP1NR(0x33c, glColor4bv, const GLbyte *, v, a0, \
  163.     , CYBERGL_BASE_NAME)
  164.  
  165. #define glColor4d(red, green, blue, alpha) \
  166.     LP4NR(0x2f4, glColor4d, GLdouble, red, fp0, GLdouble, green, fp1, GLdouble, blue, fp2, GLdouble, alpha, fp3, \
  167.     , CYBERGL_BASE_NAME)
  168.  
  169. #define glColor4dv(v) \
  170.     LP1NR(0x354, glColor4dv, const GLdouble *, v, a0, \
  171.     , CYBERGL_BASE_NAME)
  172.  
  173. #define glColor4f(red, green, blue, alpha) \
  174.     LP4NR(0x2ee, glColor4f, GLfloat, red, fp0, GLfloat, green, fp1, GLfloat, blue, fp2, GLfloat, alpha, fp3, \
  175.     , CYBERGL_BASE_NAME)
  176.  
  177. #define glColor4fv(v) \
  178.     LP1NR(0x34e, glColor4fv, const GLfloat *, v, a0, \
  179.     , CYBERGL_BASE_NAME)
  180.  
  181. #define glColor4i(red, green, blue, alpha) \
  182.     LP4NR(0x2e8, glColor4i, GLint, red, d0, GLint, green, d1, GLint, blue, d2, GLint, alpha, d3, \
  183.     , CYBERGL_BASE_NAME)
  184.  
  185. #define glColor4iv(v) \
  186.     LP1NR(0x348, glColor4iv, const GLint *, v, a0, \
  187.     , CYBERGL_BASE_NAME)
  188.  
  189. #define glColor4s(red, green, blue, alpha) \
  190.     LP4NR(0x2e2, glColor4s, GLshort, red, d0, GLshort, green, d1, GLshort, blue, d2, GLshort, alpha, d3, \
  191.     , CYBERGL_BASE_NAME)
  192.  
  193. #define glColor4sv(v) \
  194.     LP1NR(0x342, glColor4sv, const GLshort *, v, a0, \
  195.     , CYBERGL_BASE_NAME)
  196.  
  197. #define glColor4ub(red, green, blue, alpha) \
  198.     LP4NR(0x2fa, glColor4ub, GLubyte, red, d0, GLubyte, green, d1, GLubyte, blue, d2, GLubyte, alpha, d3, \
  199.     , CYBERGL_BASE_NAME)
  200.  
  201. #define glColor4ubv(v) \
  202.     LP1NR(0x35a, glColor4ubv, const GLubyte *, v, a0, \
  203.     , CYBERGL_BASE_NAME)
  204.  
  205. #define glColor4ui(red, green, blue, alpha) \
  206.     LP4NR(0x306, glColor4ui, GLuint, red, d0, GLuint, green, d1, GLuint, blue, d2, GLuint, alpha, d3, \
  207.     , CYBERGL_BASE_NAME)
  208.  
  209. #define glColor4uiv(v) \
  210.     LP1NR(0x366, glColor4uiv, const GLuint *, v, a0, \
  211.     , CYBERGL_BASE_NAME)
  212.  
  213. #define glColor4us(red, green, blue, alpha) \
  214.     LP4NR(0x300, glColor4us, GLushort, red, d0, GLushort, green, d1, GLushort, blue, d2, GLushort, alpha, d3, \
  215.     , CYBERGL_BASE_NAME)
  216.  
  217. #define glColor4usv(v) \
  218.     LP1NR(0x360, glColor4usv, const GLushort *, v, a0, \
  219.     , CYBERGL_BASE_NAME)
  220.  
  221. #define glColorMaterial(face, mode) \
  222.     LP2NR(0x5d0, glColorMaterial, GLenum, face, d0, GLenum, mode, d1, \
  223.     , CYBERGL_BASE_NAME)
  224.  
  225. #define glCullFace(mode) \
  226.     LP1NR(0x558, glCullFace, GLenum, mode, d0, \
  227.     , CYBERGL_BASE_NAME)
  228.  
  229. #define glDepthFunc(func) \
  230.     LP1NR(0x546, glDepthFunc, GLenum, func, d0, \
  231.     , CYBERGL_BASE_NAME)
  232.  
  233. #define glDepthRange(zNear, zFar) \
  234.     LP2NR(0x468, glDepthRange, GLclampd, zNear, fp0, GLclampd, zFar, fp1, \
  235.     , CYBERGL_BASE_NAME)
  236.  
  237. #define glDisable(cap) \
  238.     LP1NR(0x72, glDisable, GLenum, cap, d0, \
  239.     , CYBERGL_BASE_NAME)
  240.  
  241. #define glDrawBuffer(mode) \
  242.     LP1NR(0x528, glDrawBuffer, GLenum, mode, d0, \
  243.     , CYBERGL_BASE_NAME)
  244.  
  245. #define glDrawPixels(width, height, format, type, data) \
  246.     LP5NR(0x666, glDrawPixels, GLsizei, width, d0, GLsizei, height, d1, GLenum, format, d2, GLenum, type, d3, const void *, data, a0, \
  247.     , CYBERGL_BASE_NAME)
  248.  
  249. #define glEdgeFlag(flag) \
  250.     LP1NR(0x3cc, glEdgeFlag, GLboolean, flag, d0, \
  251.     , CYBERGL_BASE_NAME)
  252.  
  253. #define glEdgeFlagv(flag) \
  254.     LP1NR(0x3d2, glEdgeFlagv, const GLboolean *, flag, a0, \
  255.     , CYBERGL_BASE_NAME)
  256.  
  257. #define glEnable(cap) \
  258.     LP1NR(0x6c, glEnable, GLenum, cap, d0, \
  259.     , CYBERGL_BASE_NAME)
  260.  
  261. #define glEnd() \
  262.     LP0NR(0x11a, glEnd, \
  263.     , CYBERGL_BASE_NAME)
  264.  
  265. #define glFinish() \
  266.     LP0NR(0x51c, glFinish, \
  267.     , CYBERGL_BASE_NAME)
  268.  
  269. #define glFlush() \
  270.     LP0NR(0x516, glFlush, \
  271.     , CYBERGL_BASE_NAME)
  272.  
  273. #define glFogf(pname, param) \
  274.     LP2NR(0x52e, glFogf, GLenum, pname, d0, GLfloat, param, fp0, \
  275.     , CYBERGL_BASE_NAME)
  276.  
  277. #define glFogfv(pname, params) \
  278.     LP2NR(0x53a, glFogfv, GLenum, pname, d0, const GLfloat *, params, a0, \
  279.     , CYBERGL_BASE_NAME)
  280.  
  281. #define glFogi(pname, param) \
  282.     LP2NR(0x534, glFogi, GLenum, pname, d0, GLint, param, d1, \
  283.     , CYBERGL_BASE_NAME)
  284.  
  285. #define glFogiv(pname, params) \
  286.     LP2NR(0x540, glFogiv, GLenum, pname, d0, const GLint *, params, a0, \
  287.     , CYBERGL_BASE_NAME)
  288.  
  289. #define glFrontFace(mode) \
  290.     LP1NR(0x55e, glFrontFace, GLenum, mode, d0, \
  291.     , CYBERGL_BASE_NAME)
  292.  
  293. #define glFrustum_jump(frustum) \
  294.     LP1NR(0x4c2, glFrustum, const GLfrustum *, frustum, a0, \
  295.     , CYBERGL_BASE_NAME)
  296. extern __inline GLvoid glFrustum(GLdouble left,  GLdouble right, GLdouble bottom, GLdouble top,
  297.                                  GLdouble zNear, GLdouble zFar) {
  298.   GLfrustum sfrustum;
  299.   
  300.   sfrustum.left = left;
  301.   sfrustum.right = right;
  302.   sfrustum.bottom = bottom;
  303.   sfrustum.top = top;
  304.   sfrustum.zNear = zNear;
  305.   sfrustum.zFar = zFar;
  306.   
  307.   glFrustum_jump(&sfrustum);
  308. }
  309.  
  310. #define glGetBooleanv(pname, params) \
  311.     LP2NR(0x7e, glGetBooleanv, GLenum, pname, d0, GLboolean *, params, a0, \
  312.     , CYBERGL_BASE_NAME)
  313.  
  314. #define glGetClipPlane(plane, equation) \
  315.     LP2NR(0x96, glGetClipPlane, GLenum, plane, d0, GLdouble *, equation, a0, \
  316.     , CYBERGL_BASE_NAME)
  317.  
  318. #define glGetDoublev(pname, params) \
  319.     LP2NR(0x90, glGetDoublev, GLenum, pname, d0, GLdouble *, params, a0, \
  320.     , CYBERGL_BASE_NAME)
  321.  
  322. #define glGetError() \
  323.     LP0(0x66, GLenum, glGetError, \
  324.     , CYBERGL_BASE_NAME)
  325.  
  326. #define glGetFloatv(pname, params) \
  327.     LP2NR(0x8a, glGetFloatv, GLenum, pname, d0, GLfloat *, params, a0, \
  328.     , CYBERGL_BASE_NAME)
  329.  
  330. #define glGetIntegerv(pname, params) \
  331.     LP2NR(0x84, glGetIntegerv, GLenum, pname, d0, GLint *, params, a0, \
  332.     , CYBERGL_BASE_NAME)
  333.  
  334. #define glGetLightfv(light, pname, params) \
  335.     LP3NR(0x9c, glGetLightfv, GLenum, light, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  336.     , CYBERGL_BASE_NAME)
  337.  
  338. #define glGetLightiv(light, pname, params) \
  339.     LP3NR(0xa2, glGetLightiv, GLenum, light, d0, GLenum, pname, d1, GLint *, params, a0, \
  340.     , CYBERGL_BASE_NAME)
  341.  
  342. #define glGetMaterialfv(face, pname, params) \
  343.     LP3NR(0xa8, glGetMaterialfv, GLenum, face, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  344.     , CYBERGL_BASE_NAME)
  345.  
  346. #define glGetMaterialiv(face, pname, params) \
  347.     LP3NR(0xae, glGetMaterialiv, GLenum, face, d0, GLenum, pname, d1, GLint *, params, a0, \
  348.     , CYBERGL_BASE_NAME)
  349.  
  350. #define glGetPixelMapfv(map, values) \
  351.     LP2NR(0xc6, glGetPixelMapfv, GLenum, map, d0, GLfloat *, values, a0, \
  352.     , CYBERGL_BASE_NAME)
  353.  
  354. #define glGetPixelMapuiv(map, values) \
  355.     LP2NR(0xcc, glGetPixelMapuiv, GLenum, map, d0, GLuint *, values, a0, \
  356.     , CYBERGL_BASE_NAME)
  357.  
  358. #define glGetPixelMapusv(map, values) \
  359.     LP2NR(0xd2, glGetPixelMapusv, GLenum, map, d0, GLushort *, values, a0, \
  360.     , CYBERGL_BASE_NAME)
  361.  
  362. #define glGetString(name) \
  363.     LP1(0x102, GLubyte *, glGetString, GLenum, name, d0, \
  364.     , CYBERGL_BASE_NAME)
  365.  
  366. #define glGetTexEnvfv(target, pname, params) \
  367.     LP3NR(0xd8, glGetTexEnvfv, GLenum, target, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  368.     , CYBERGL_BASE_NAME)
  369.  
  370. #define glGetTexEnviv(target, pname, params) \
  371.     LP3NR(0xde, glGetTexEnviv, GLenum, target, d0, GLenum, pname, d1, GLint *, params, a0, \
  372.     , CYBERGL_BASE_NAME)
  373.  
  374. #define glGetTexGendv(coord, pname, params) \
  375.     LP3NR(0xb4, glGetTexGendv, GLenum, coord, d0, GLenum, pname, d1, GLdouble *, params, a0, \
  376.     , CYBERGL_BASE_NAME)
  377.  
  378. #define glGetTexGenfv(coord, pname, params) \
  379.     LP3NR(0xba, glGetTexGenfv, GLenum, coord, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  380.     , CYBERGL_BASE_NAME)
  381.  
  382. #define glGetTexGeniv(coord, pname, params) \
  383.     LP3NR(0xc0, glGetTexGeniv, GLenum, coord, d0, GLenum, pname, d1, GLint *, params, a0, \
  384.     , CYBERGL_BASE_NAME)
  385.  
  386. #define glGetTexImage(target, level, format, type, pixels) \
  387.     LP5NR(0xfc, glGetTexImage, GLenum, target, d0, GLint, level, d1, GLenum, format, d2, GLenum, type, d3, void *, pixels, a0, \
  388.     , CYBERGL_BASE_NAME)
  389.  
  390. #define glGetTexLevelParameterfv(target, level, pname, params) \
  391.     LP4NR(0xe4, glGetTexLevelParameterfv, GLenum, target, d0, GLint, level, d1, GLenum, pname, d2, GLfloat *, params, a0, \
  392.     , CYBERGL_BASE_NAME)
  393.  
  394. #define glGetTexLevelParameteriv(target, level, pname, params) \
  395.     LP4NR(0xea, glGetTexLevelParameteriv, GLenum, target, d0, GLint, level, d1, GLenum, pname, d2, GLint *, params, a0, \
  396.     , CYBERGL_BASE_NAME)
  397.  
  398. #define glGetTexParameterfv(target, pname, params) \
  399.     LP3NR(0xf0, glGetTexParameterfv, GLenum, target, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  400.     , CYBERGL_BASE_NAME)
  401.  
  402. #define glGetTexParameteriv(target, pname, params) \
  403.     LP3NR(0xf6, glGetTexParameteriv, GLenum, target, d0, GLenum, pname, d1, GLint *, params, a0, \
  404.     , CYBERGL_BASE_NAME)
  405.  
  406. #define glHint(target, mode) \
  407.     LP2NR(0x522, glHint, GLenum, target, d0, GLenum, mode, d1, \
  408.     , CYBERGL_BASE_NAME)
  409.  
  410. #define glIndexd(index) \
  411.     LP1NR(0x37e, glIndexd, GLdouble, index, fp0, \
  412.     , CYBERGL_BASE_NAME)
  413.  
  414. #define glIndexdv(v) \
  415.     LP1NR(0x396, glIndexdv, const GLdouble *, v, a0, \
  416.     , CYBERGL_BASE_NAME)
  417.  
  418. #define glIndexf(index) \
  419.     LP1NR(0x378, glIndexf, GLfloat, index, fp0, \
  420.     , CYBERGL_BASE_NAME)
  421.  
  422. #define glIndexfv(v) \
  423.     LP1NR(0x390, glIndexfv, const GLfloat *, v, a0, \
  424.     , CYBERGL_BASE_NAME)
  425.  
  426. #define glIndexi(index) \
  427.     LP1NR(0x372, glIndexi, GLint, index, d0, \
  428.     , CYBERGL_BASE_NAME)
  429.  
  430. #define glIndexiv(v) \
  431.     LP1NR(0x38a, glIndexiv, const GLint *, v, a0, \
  432.     , CYBERGL_BASE_NAME)
  433.  
  434. #define glIndexs(index) \
  435.     LP1NR(0x36c, glIndexs, GLshort, index, d0, \
  436.     , CYBERGL_BASE_NAME)
  437.  
  438. #define glIndexsv(v) \
  439.     LP1NR(0x384, glIndexsv, const GLshort *, v, a0, \
  440.     , CYBERGL_BASE_NAME)
  441.  
  442. #define glInitNames() \
  443.     LP0NR(0x56a, glInitNames, \
  444.     , CYBERGL_BASE_NAME)
  445.  
  446. #define glIsEnabled(cap) \
  447.     LP1(0x78, GLboolean, glIsEnabled, GLenum, cap, d0, \
  448.     , CYBERGL_BASE_NAME)
  449.  
  450. #define glLightModelf(pname, param) \
  451.     LP2NR(0x5a0, glLightModelf, GLenum, pname, d0, GLfloat, param, fp0, \
  452.     , CYBERGL_BASE_NAME)
  453.  
  454. #define glLightModelfv(pname, params) \
  455.     LP2NR(0x5ac, glLightModelfv, GLenum, pname, d0, GLfloat *, params, a0, \
  456.     , CYBERGL_BASE_NAME)
  457.  
  458. #define glLightModeli(pname, param) \
  459.     LP2NR(0x5a6, glLightModeli, GLenum, pname, d0, GLint, param, d1, \
  460.     , CYBERGL_BASE_NAME)
  461.  
  462. #define glLightModeliv(pname, params) \
  463.     LP2NR(0x5b2, glLightModeliv, GLenum, pname, d0, GLint *, params, a0, \
  464.     , CYBERGL_BASE_NAME)
  465.  
  466. #define glLightf(light, pname, param) \
  467.     LP3NR(0x588, glLightf, GLenum, light, d0, GLenum, pname, d1, GLfloat, param, fp0, \
  468.     , CYBERGL_BASE_NAME)
  469.  
  470. #define glLightfv(light, pname, params) \
  471.     LP3NR(0x594, glLightfv, GLenum, light, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  472.     , CYBERGL_BASE_NAME)
  473.  
  474. #define glLighti(light, pname, param) \
  475.     LP3NR(0x58e, glLighti, GLenum, light, d0, GLenum, pname, d1, GLint, param, d2, \
  476.     , CYBERGL_BASE_NAME)
  477.  
  478. #define glLightiv(light, pname, params) \
  479.     LP3NR(0x59a, glLightiv, GLenum, light, d0, GLenum, pname, d1, GLint *, params, a0, \
  480.     , CYBERGL_BASE_NAME)
  481.  
  482. #define glLoadIdentity() \
  483.     LP0NR(0x492, glLoadIdentity, \
  484.     , CYBERGL_BASE_NAME)
  485.  
  486. #define glLoadMatrixd(m) \
  487.     LP1NR(0x480, glLoadMatrixd, const GLdouble *, m, a0, \
  488.     , CYBERGL_BASE_NAME)
  489.  
  490. #define glLoadMatrixf(m) \
  491.     LP1NR(0x47a, glLoadMatrixf, const GLfloat *, m, a0, \
  492.     , CYBERGL_BASE_NAME)
  493.  
  494. #define glLoadName(name) \
  495.     LP1NR(0x570, glLoadName, GLuint, name, d0, \
  496.     , CYBERGL_BASE_NAME)
  497.  
  498. #define glLookAt_jump(lookAt) \
  499.     LP1NR(0x4ec, glLookAt, const GLlookAt *, lookAt, a0, \
  500.     , CYBERGL_BASE_NAME)
  501. extern __inline GLvoid glLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, 
  502.                                 GLdouble centerx, GLdouble centery, GLdouble centerz, 
  503.                                 GLdouble upx, GLdouble upy, GLdouble upz) {
  504.   GLlookAt slookat;
  505.   
  506.   slookat.eyex = eyex;
  507.   slookat.eyey = eyey;
  508.   slookat.eyez = eyez;
  509.   slookat.centerx = centerx;
  510.   slookat.centery = centery;
  511.   slookat.centerz = centerz;
  512.   slookat.upx = upx;
  513.   slookat.upy = upy;
  514.   slookat.upz = upz;
  515.   
  516.   glLookAt_jump(&slookat);
  517. }
  518.  
  519. #define glMaterialf(face, pname, param) \
  520.     LP3NR(0x5b8, glMaterialf, GLenum, face, d0, GLenum, pname, d1, GLfloat, param, fp0, \
  521.     , CYBERGL_BASE_NAME)
  522.  
  523. #define glMaterialfv(face, pname, params) \
  524.     LP3NR(0x5c4, glMaterialfv, GLenum, face, d0, GLenum, pname, d1, GLfloat *, params, a0, \
  525.     , CYBERGL_BASE_NAME)
  526.  
  527. #define glMateriali(face, pname, param) \
  528.     LP3NR(0x5be, glMateriali, GLenum, face, d0, GLenum, pname, d1, GLint, param, d2, \
  529.     , CYBERGL_BASE_NAME)
  530.  
  531. #define glMaterialiv(face, pname, params) \
  532.     LP3NR(0x5ca, glMaterialiv, GLenum, face, d0, GLenum, pname, d1, GLint *, params, a0, \
  533.     , CYBERGL_BASE_NAME)
  534.  
  535. #define glMatrixMode(mode) \
  536.     LP1NR(0x474, glMatrixMode, GLenum, mode, d0, \
  537.     , CYBERGL_BASE_NAME)
  538.  
  539. #define glMultMatrixd(m) \
  540.     LP1NR(0x48c, glMultMatrixd, const GLdouble *, m, a0, \
  541.     , CYBERGL_BASE_NAME)
  542.  
  543. #define glMultMatrixf(m) \
  544.     LP1NR(0x486, glMultMatrixf, const GLfloat *, m, a0, \
  545.     , CYBERGL_BASE_NAME)
  546.  
  547. #define glNormal3b(nx, ny, nz) \
  548.     LP3NR(0x270, glNormal3b, GLbyte, nx, d0, GLbyte, ny, d1, GLbyte, nz, d2, \
  549.     , CYBERGL_BASE_NAME)
  550.  
  551. #define glNormal3bv(v) \
  552.     LP1NR(0x28e, glNormal3bv, const GLbyte *, v, a0, \
  553.     , CYBERGL_BASE_NAME)
  554.  
  555. #define glNormal3d(nx, ny, nz) \
  556.     LP3NR(0x288, glNormal3d, GLdouble, nx, fp0, GLdouble, ny, fp1, GLdouble, nz, fp2, \
  557.     , CYBERGL_BASE_NAME)
  558.  
  559. #define glNormal3dv(v) \
  560.     LP1NR(0x2a6, glNormal3dv, const GLdouble *, v, a0, \
  561.     , CYBERGL_BASE_NAME)
  562.  
  563. #define glNormal3f(nx, ny, nz) \
  564.     LP3NR(0x282, glNormal3f, GLfloat, nx, fp0, GLfloat, ny, fp1, GLfloat, nz, fp2, \
  565.     , CYBERGL_BASE_NAME)
  566.  
  567. #define glNormal3fv(v) \
  568.     LP1NR(0x2a0, glNormal3fv, const GLfloat *, v, a0, \
  569.     , CYBERGL_BASE_NAME)
  570.  
  571. #define glNormal3i(nx, ny, nz) \
  572.     LP3NR(0x27c, glNormal3i, GLint, nx, d0, GLint, ny, d1, GLint, nz, d2, \
  573.     , CYBERGL_BASE_NAME)
  574.  
  575. #define glNormal3iv(v) \
  576.     LP1NR(0x29a, glNormal3iv, const GLint *, v, a0, \
  577.     , CYBERGL_BASE_NAME)
  578.  
  579. #define glNormal3s(nx, ny, nz) \
  580.     LP3NR(0x276, glNormal3s, GLshort, nx, d0, GLshort, ny, d1, GLshort, nz, d2, \
  581.     , CYBERGL_BASE_NAME)
  582.  
  583. #define glNormal3sv(v) \
  584.     LP1NR(0x294, glNormal3sv, const GLshort *, v, a0, \
  585.     , CYBERGL_BASE_NAME)
  586.  
  587. #define glOrtho_jump(ortho) \
  588.     LP1NR(0x4c2, glOrtho, const GLortho *, ortho, a0, \
  589.     , CYBERGL_BASE_NAME)
  590. extern __inline GLvoid glOrtho(GLdouble left,  GLdouble right, GLdouble bottom, GLdouble top,
  591.                                GLdouble zNear, GLdouble zFar) {
  592.   GLortho sortho;
  593.   
  594.   sortho.left = left;
  595.   sortho.right = right;
  596.   sortho.bottom = bottom;
  597.   sortho.top = top;
  598.   sortho.zNear = zNear;
  599.   sortho.zFar = zFar;
  600.   
  601.   glOrtho_jump(&sortho);
  602. }
  603.  
  604. #define glOrtho2D(left, right, bottom, top) \
  605.     LP4NR(0x4d4, glOrtho2D, GLdouble, left, fp0, GLdouble, right, fp1, GLdouble, bottom, fp2, GLdouble, top, fp3, \
  606.     , CYBERGL_BASE_NAME)
  607.  
  608. #define glPerspective(fovy, aspect, zNear, zFar) \
  609.     LP4NR(0x4e6, glPerspective, GLdouble, fovy, fp0, GLdouble, aspect, fp1, GLdouble, zNear, fp2, GLdouble, zFar, fp3, \
  610.     , CYBERGL_BASE_NAME)
  611.  
  612. #define glPickMatrix(x, y, width, height) \
  613.     LP4NR(0x4f2, glPickMatrix, GLdouble, x, fp0, GLdouble, y, fp1, GLdouble, width, fp2, GLdouble, height, fp3, \
  614.     , CYBERGL_BASE_NAME)
  615.  
  616. #define glPixelMapfv(map, mapsize, values) \
  617.     LP3NR(0x65a, glPixelMapfv, GLenum, map, d0, GLsizei, mapsize, d1, const GLfloat, values, a0, \
  618.     , CYBERGL_BASE_NAME)
  619.  
  620. #define glPixelMapuiv(map, mapsize, values) \
  621.     LP3NR(0x64e, glPixelMapuiv, GLenum, map, d0, GLsizei, mapsize, d1, const GLuint, values, a0, \
  622.     , CYBERGL_BASE_NAME)
  623.  
  624. #define glPixelMapusv(map, mapsize, values) \
  625.     LP3NR(0x654, glPixelMapusv, GLenum, map, d0, GLsizei, mapsize, d1, const GLushort, values, a0, \
  626.     , CYBERGL_BASE_NAME)
  627.  
  628. #define glPixelStoref(pname, param) \
  629.     LP2NR(0x63c, glPixelStoref, GLenum, pname, d0, GLfloat, param, fp0, \
  630.     , CYBERGL_BASE_NAME)
  631.  
  632. #define glPixelStorei(pname, param) \
  633.     LP2NR(0x636, glPixelStorei, GLenum, pname, d0, GLint, param, d1, \
  634.     , CYBERGL_BASE_NAME)
  635.  
  636. #define glPixelTransferf(pname, param) \
  637.     LP2NR(0x648, glPixelTransferf, GLenum, pname, d0, GLfloat, param, fp0, \
  638.     , CYBERGL_BASE_NAME)
  639.  
  640. #define glPixelTransferi(pname, param) \
  641.     LP2NR(0x642, glPixelTransferi, GLenum, pname, d0, GLint, param, d1, \
  642.     , CYBERGL_BASE_NAME)
  643.  
  644. #define glPixelZoom(xfactor, yfactor) \
  645.     LP2NR(0x660, glPixelZoom, GLfloat, xfactor, fp0, GLfloat, yfactor, fp1, \
  646.     , CYBERGL_BASE_NAME)
  647.  
  648. #define glPolygonMode(face, mode) \
  649.     LP2NR(0x54c, glPolygonMode, GLenum, face, d0, GLenum, mode, d1, \
  650.     , CYBERGL_BASE_NAME)
  651.  
  652. #define glPopAttrib() \
  653.     LP0NR(0x10e, glPopAttrib, \
  654.     , CYBERGL_BASE_NAME)
  655.  
  656. #define glPopMatrix() \
  657.     LP0NR(0x4ce, glPopMatrix, \
  658.     , CYBERGL_BASE_NAME)
  659.  
  660. #define glPopName() \
  661.     LP0NR(0x57c, glPopName, \
  662.     , CYBERGL_BASE_NAME)
  663.  
  664. #define glProject(objx, objy, objz, winx, winy, winz) \
  665.     LP6(0x4da, GLboolean, glProject, GLdouble, objx, fp0, GLdouble, objy, fp1, GLdouble, objz, fp2, GLdouble *, winx, a0, GLdouble *, winy, a1, GLdouble *, winz, a2, \
  666.     , CYBERGL_BASE_NAME)
  667.  
  668. #define glPushAttrib(mask) \
  669.     LP1NR(0x108, glPushAttrib, GLbitfield, mask, d0, \
  670.     , CYBERGL_BASE_NAME)
  671.  
  672. #define glPushMatrix() \
  673.     LP0NR(0x4c8, glPushMatrix, \
  674.     , CYBERGL_BASE_NAME)
  675.  
  676. #define glPushName(name) \
  677.     LP1NR(0x576, glPushName, GLuint, name, d0, \
  678.     , CYBERGL_BASE_NAME)
  679.  
  680. #define glRasterPos2d(s, t) \
  681.     LP2NR(0x3ea, glRasterPos2d, GLdouble, s, fp0, GLdouble, t, fp1, \
  682.     , CYBERGL_BASE_NAME)
  683.  
  684. #define glRasterPos2dv(v) \
  685.     LP1NR(0x432, glRasterPos2dv, const GLdouble *, v, a0, \
  686.     , CYBERGL_BASE_NAME)
  687.  
  688. #define glRasterPos2f(s, t) \
  689.     LP2NR(0x3e4, glRasterPos2f, GLfloat, s, fp0, GLfloat, t, fp1, \
  690.     , CYBERGL_BASE_NAME)
  691.  
  692. #define glRasterPos2fv(v) \
  693.     LP1NR(0x42c, glRasterPos2fv, const GLfloat *, v, a0, \
  694.     , CYBERGL_BASE_NAME)
  695.  
  696. #define glRasterPos2i(s, t) \
  697.     LP2NR(0x3de, glRasterPos2i, GLint, s, d0, GLint, t, d1, \
  698.     , CYBERGL_BASE_NAME)
  699.  
  700. #define glRasterPos2iv(v) \
  701.     LP1NR(0x426, glRasterPos2iv, const GLint *, v, a0, \
  702.     , CYBERGL_BASE_NAME)
  703.  
  704. #define glRasterPos2s(s, t) \
  705.     LP2NR(0x3d8, glRasterPos2s, GLshort, s, d0, GLshort, t, d1, \
  706.     , CYBERGL_BASE_NAME)
  707.  
  708. #define glRasterPos2sv(v) \
  709.     LP1NR(0x420, glRasterPos2sv, const GLshort *, v, a0, \
  710.     , CYBERGL_BASE_NAME)
  711.  
  712. #define glRasterPos3d(s, t, r) \
  713.     LP3NR(0x402, glRasterPos3d, GLdouble, s, fp0, GLdouble, t, fp1, GLdouble, r, fp2, \
  714.     , CYBERGL_BASE_NAME)
  715.  
  716. #define glRasterPos3dv(v) \
  717.     LP1NR(0x44a, glRasterPos3dv, const GLdouble *, v, a0, \
  718.     , CYBERGL_BASE_NAME)
  719.  
  720. #define glRasterPos3f(s, t, r) \
  721.     LP3NR(0x3fc, glRasterPos3f, GLfloat, s, fp0, GLfloat, t, fp1, GLfloat, r, fp2, \
  722.     , CYBERGL_BASE_NAME)
  723.  
  724. #define glRasterPos3fv(v) \
  725.     LP1NR(0x444, glRasterPos3fv, const GLfloat *, v, a0, \
  726.     , CYBERGL_BASE_NAME)
  727.  
  728. #define glRasterPos3i(s, t, r) \
  729.     LP3NR(0x3f6, glRasterPos3i, GLint, s, d0, GLint, t, d1, GLint, r, d2, \
  730.     , CYBERGL_BASE_NAME)
  731.  
  732. #define glRasterPos3iv(v) \
  733.     LP1NR(0x43e, glRasterPos3iv, const GLint *, v, a0, \
  734.     , CYBERGL_BASE_NAME)
  735.  
  736. #define glRasterPos3s(s, t, r) \
  737.     LP3NR(0x3f0, glRasterPos3s, GLshort, s, d0, GLshort, t, d1, GLshort, r, d2, \
  738.     , CYBERGL_BASE_NAME)
  739.  
  740. #define glRasterPos3sv(v) \
  741.     LP1NR(0x438, glRasterPos3sv, const GLshort *, v, a0, \
  742.     , CYBERGL_BASE_NAME)
  743.  
  744. #define glRasterPos4d(s, t, r, q) \
  745.     LP4NR(0x41a, glRasterPos4d, GLdouble, s, fp0, GLdouble, t, fp1, GLdouble, r, fp2, GLdouble, q, fp3, \
  746.     , CYBERGL_BASE_NAME)
  747.  
  748. #define glRasterPos4dv(v) \
  749.     LP1NR(0x462, glRasterPos4dv, const GLdouble *, v, a0, \
  750.     , CYBERGL_BASE_NAME)
  751.  
  752. #define glRasterPos4f(s, t, r, q) \
  753.     LP4NR(0x414, glRasterPos4f, GLfloat, s, fp0, GLfloat, t, fp1, GLfloat, r, fp2, GLfloat, q, fp3, \
  754.     , CYBERGL_BASE_NAME)
  755.  
  756. #define glRasterPos4fv(v) \
  757.     LP1NR(0x45c, glRasterPos4fv, const GLfloat *, v, a0, \
  758.     , CYBERGL_BASE_NAME)
  759.  
  760. #define glRasterPos4i(s, t, r, q) \
  761.     LP4NR(0x40e, glRasterPos4i, GLint, s, d0, GLint, t, d1, GLint, r, d2, GLint, q, d3, \
  762.     , CYBERGL_BASE_NAME)
  763.  
  764. #define glRasterPos4iv(v) \
  765.     LP1NR(0x456, glRasterPos4iv, const GLint *, v, a0, \
  766.     , CYBERGL_BASE_NAME)
  767.  
  768. #define glRasterPos4s(s, t, r, q) \
  769.     LP4NR(0x408, glRasterPos4s, GLshort, s, d0, GLshort, t, d1, GLshort, r, d2, GLshort, q, d3, \
  770.     , CYBERGL_BASE_NAME)
  771.  
  772. #define glRasterPos4sv(v) \
  773.     LP1NR(0x450, glRasterPos4sv, const GLshort *, v, a0, \
  774.     , CYBERGL_BASE_NAME)
  775.  
  776. #define glRectd(x1, y1, x2, y2) \
  777.     LP4NR(0x3ae, glRectd, GLdouble, x1, fp0, GLdouble, y1, fp1, GLdouble, x2, fp2, GLdouble, y2, fp3, \
  778.     , CYBERGL_BASE_NAME)
  779.  
  780. #define glRectdv(v1, v2) \
  781.     LP2NR(0x3c6, glRectdv, const GLdouble *, v1, a0, const GLdouble *, v2, a1, \
  782.     , CYBERGL_BASE_NAME)
  783.  
  784. #define glRectf(x1, y1, x2, y2) \
  785.     LP4NR(0x3a8, glRectf, GLfloat, x1, fp0, GLfloat, y1, fp1, GLfloat, x2, fp2, GLfloat, y2, fp3, \
  786.     , CYBERGL_BASE_NAME)
  787.  
  788. #define glRectfv(v1, v2) \
  789.     LP2NR(0x3c0, glRectfv, const GLfloat *, v1, a0, const GLfloat *, v2, a1, \
  790.     , CYBERGL_BASE_NAME)
  791.  
  792. #define glRecti(x1, y1, x2, y2) \
  793.     LP4NR(0x3a2, glRecti, GLint, x1, d0, GLint, y1, d1, GLint, x2, d2, GLint, y2, d3, \
  794.     , CYBERGL_BASE_NAME)
  795.  
  796. #define glRectiv(v1, v2) \
  797.     LP2NR(0x3ba, glRectiv, const GLint *, v1, a0, const GLint *, v2, a1, \
  798.     , CYBERGL_BASE_NAME)
  799.  
  800. #define glRects(x1, y1, x2, y2) \
  801.     LP4NR(0x39c, glRects, GLshort, x1, d0, GLshort, y1, d1, GLshort, x2, d2, GLshort, y2, d3, \
  802.     , CYBERGL_BASE_NAME)
  803.  
  804. #define glRectsv(v1, v2) \
  805.     LP2NR(0x3b4, glRectsv, const GLshort *, v1, a0, const GLshort *, v2, a1, \
  806.     , CYBERGL_BASE_NAME)
  807.  
  808. #define glRenderMode(mode) \
  809.     LP1(0x564, GLint, glRenderMode, GLenum, mode, d0, \
  810.     , CYBERGL_BASE_NAME)
  811.  
  812. #define glRotated(angle, x, y, z) \
  813.     LP4NR(0x49e, glRotated, GLdouble, angle, fp0, GLdouble, x, fp1, GLdouble, y, fp2, GLdouble, z, fp3, \
  814.     , CYBERGL_BASE_NAME)
  815.  
  816. #define glRotatef(angle, x, y, z) \
  817.     LP4NR(0x498, glRotatef, GLfloat, angle, fp0, GLfloat, x, fp1, GLfloat, y, fp2, GLfloat, z, fp3, \
  818.     , CYBERGL_BASE_NAME)
  819.  
  820. #define glScaled(x, y, z) \
  821.     LP3NR(0x4b6, glScaled, GLdouble, x, fp0, GLdouble, y, fp1, GLdouble, z, fp2, \
  822.     , CYBERGL_BASE_NAME)
  823.  
  824. #define glScalef(x, y, z) \
  825.     LP3NR(0x4b0, glScalef, GLfloat, x, fp0, GLfloat, y, fp1, GLfloat, z, fp2, \
  826.     , CYBERGL_BASE_NAME)
  827.  
  828. #define glSelectBuffer(size, buffer) \
  829.     LP2NR(0x582, glSelectBuffer, GLsizei, size, d0, GLuint *, buffer, a0, \
  830.     , CYBERGL_BASE_NAME)
  831.  
  832. #define glShadeModel(mode) \
  833.     LP1NR(0x552, glShadeModel, GLenum, mode, d0, \
  834.     , CYBERGL_BASE_NAME)
  835.  
  836. #define glTexCoord1d(s) \
  837.     LP1NR(0x1c2, glTexCoord1d, GLdouble, s, fp0, \
  838.     , CYBERGL_BASE_NAME)
  839.  
  840. #define glTexCoord1dv(v) \
  841.     LP1NR(0x222, glTexCoord1dv, const GLdouble *, v, a0, \
  842.     , CYBERGL_BASE_NAME)
  843.  
  844. #define glTexCoord1f(s) \
  845.     LP1NR(0x1bc, glTexCoord1f, GLfloat, s, fp0, \
  846.     , CYBERGL_BASE_NAME)
  847.  
  848. #define glTexCoord1fv(v) \
  849.     LP1NR(0x21c, glTexCoord1fv, const GLfloat *, v, a0, \
  850.     , CYBERGL_BASE_NAME)
  851.  
  852. #define glTexCoord1i(s) \
  853.     LP1NR(0x1b6, glTexCoord1i, GLint, s, d0, \
  854.     , CYBERGL_BASE_NAME)
  855.  
  856. #define glTexCoord1iv(v) \
  857.     LP1NR(0x216, glTexCoord1iv, const GLint *, v, a0, \
  858.     , CYBERGL_BASE_NAME)
  859.  
  860. #define glTexCoord1s(s) \
  861.     LP1NR(0x1b0, glTexCoord1s, GLshort, s, d0, \
  862.     , CYBERGL_BASE_NAME)
  863.  
  864. #define glTexCoord1sv(v) \
  865.     LP1NR(0x210, glTexCoord1sv, const GLshort *, v, a0, \
  866.     , CYBERGL_BASE_NAME)
  867.  
  868. #define glTexCoord2d(s, t) \
  869.     LP2NR(0x1da, glTexCoord2d, GLdouble, s, fp0, GLdouble, t, fp1, \
  870.     , CYBERGL_BASE_NAME)
  871.  
  872. #define glTexCoord2dv(v) \
  873.     LP1NR(0x23a, glTexCoord2dv, const GLdouble *, v, a0, \
  874.     , CYBERGL_BASE_NAME)
  875.  
  876. #define glTexCoord2f(s, t) \
  877.     LP2NR(0x1d4, glTexCoord2f, GLfloat, s, fp0, GLfloat, t, fp1, \
  878.     , CYBERGL_BASE_NAME)
  879.  
  880. #define glTexCoord2fv(v) \
  881.     LP1NR(0x234, glTexCoord2fv, const GLfloat *, v, a0, \
  882.     , CYBERGL_BASE_NAME)
  883.  
  884. #define glTexCoord2i(s, t) \
  885.     LP2NR(0x1ce, glTexCoord2i, GLint, s, d0, GLint, t, d1, \
  886.     , CYBERGL_BASE_NAME)
  887.  
  888. #define glTexCoord2iv(v) \
  889.     LP1NR(0x22e, glTexCoord2iv, const GLint *, v, a0, \
  890.     , CYBERGL_BASE_NAME)
  891.  
  892. #define glTexCoord2s(s, t) \
  893.     LP2NR(0x1c8, glTexCoord2s, GLshort, s, d0, GLshort, t, d1, \
  894.     , CYBERGL_BASE_NAME)
  895.  
  896. #define glTexCoord2sv(v) \
  897.     LP1NR(0x228, glTexCoord2sv, const GLshort *, v, a0, \
  898.     , CYBERGL_BASE_NAME)
  899.  
  900. #define glTexCoord3d(s, t, r) \
  901.     LP3NR(0x1f2, glTexCoord3d, GLdouble, s, fp0, GLdouble, t, fp1, GLdouble, r, fp2, \
  902.     , CYBERGL_BASE_NAME)
  903.  
  904. #define glTexCoord3dv(v) \
  905.     LP1NR(0x252, glTexCoord3dv, const GLdouble *, v, a0, \
  906.     , CYBERGL_BASE_NAME)
  907.  
  908. #define glTexCoord3f(s, t, r) \
  909.     LP3NR(0x1ec, glTexCoord3f, GLfloat, s, fp0, GLfloat, t, fp1, GLfloat, r, fp2, \
  910.     , CYBERGL_BASE_NAME)
  911.  
  912. #define glTexCoord3fv(v) \
  913.     LP1NR(0x24c, glTexCoord3fv, const GLfloat *, v, a0, \
  914.     , CYBERGL_BASE_NAME)
  915.  
  916. #define glTexCoord3i(s, t, r) \
  917.     LP3NR(0x1e6, glTexCoord3i, GLint, s, d0, GLint, t, d1, GLint, r, d2, \
  918.     , CYBERGL_BASE_NAME)
  919.  
  920. #define glTexCoord3iv(v) \
  921.     LP1NR(0x246, glTexCoord3iv, const GLint *, v, a0, \
  922.     , CYBERGL_BASE_NAME)
  923.  
  924. #define glTexCoord3s(s, t, r) \
  925.     LP3NR(0x1e0, glTexCoord3s, GLshort, s, d0, GLshort, t, d1, GLshort, r, d2, \
  926.     , CYBERGL_BASE_NAME)
  927.  
  928. #define glTexCoord3sv(v) \
  929.     LP1NR(0x240, glTexCoord3sv, const GLshort *, v, a0, \
  930.     , CYBERGL_BASE_NAME)
  931.  
  932. #define glTexCoord4d(s, t, r, q) \
  933.     LP4NR(0x20a, glTexCoord4d, GLdouble, s, fp0, GLdouble, t, fp1, GLdouble, r, fp2, GLdouble, q, fp3, \
  934.     , CYBERGL_BASE_NAME)
  935.  
  936. #define glTexCoord4dv(v) \
  937.     LP1NR(0x26a, glTexCoord4dv, const GLdouble *, v, a0, \
  938.     , CYBERGL_BASE_NAME)
  939.  
  940. #define glTexCoord4f(s, t, r, q) \
  941.     LP4NR(0x204, glTexCoord4f, GLfloat, s, fp0, GLfloat, t, fp1, GLfloat, r, fp2, GLfloat, q, fp3, \
  942.     , CYBERGL_BASE_NAME)
  943.  
  944. #define glTexCoord4fv(v) \
  945.     LP1NR(0x264, glTexCoord4fv, const GLfloat *, v, a0, \
  946.     , CYBERGL_BASE_NAME)
  947.  
  948. #define glTexCoord4i(s, t, r, q) \
  949.     LP4NR(0x1fe, glTexCoord4i, GLint, s, d0, GLint, t, d1, GLint, r, d2, GLint, q, d3, \
  950.     , CYBERGL_BASE_NAME)
  951.  
  952. #define glTexCoord4iv(v) \
  953.     LP1NR(0x25e, glTexCoord4iv, const GLint *, v, a0, \
  954.     , CYBERGL_BASE_NAME)
  955.  
  956. #define glTexCoord4s(s, t, r, q) \
  957.     LP4NR(0x1f8, glTexCoord4s, GLshort, s, d0, GLshort, t, d1, GLshort, r, d2, GLshort, q, d3, \
  958.     , CYBERGL_BASE_NAME)
  959.  
  960. #define glTexCoord4sv(v) \
  961.     LP1NR(0x258, glTexCoord4sv, const GLshort *, v, a0, \
  962.     , CYBERGL_BASE_NAME)
  963.  
  964. #define glTexEnvf(target, pname, param) \
  965.     LP3NR(0x5fa, glTexEnvf, GLenum, target, d0, GLenum, pname, d1, GLfloat, param, fp0, \
  966.     , CYBERGL_BASE_NAME)
  967.  
  968. #define glTexEnvfv(target, pname, params) \
  969.     LP3NR(0x606, glTexEnvfv, GLenum, target, d0, GLenum, pname, d1, const GLfloat *, params, a0, \
  970.     , CYBERGL_BASE_NAME)
  971.  
  972. #define glTexEnvi(target, pname, param) \
  973.     LP3NR(0x600, glTexEnvi, GLenum, target, d0, GLenum, pname, d1, GLint, param, d2, \
  974.     , CYBERGL_BASE_NAME)
  975.  
  976. #define glTexEnviv(target, pname, params) \
  977.     LP3NR(0x60c, glTexEnviv, GLenum, target, d0, GLenum, pname, d1, const GLint *, params, a0, \
  978.     , CYBERGL_BASE_NAME)
  979.  
  980. #define glTexGend(coord, pname, param) \
  981.     LP3NR(0x5e2, glTexGend, GLenum, coord, d0, GLenum, pname, d1, GLdouble, param, fp0, \
  982.     , CYBERGL_BASE_NAME)
  983.  
  984. #define glTexGendv(coord, pname, params) \
  985.     LP3NR(0x5f4, glTexGendv, GLenum, coord, d0, GLenum, pname, d1, const GLdouble *, params, a0, \
  986.     , CYBERGL_BASE_NAME)
  987.  
  988. #define glTexGenf(coord, pname, param) \
  989.     LP3NR(0x5dc, glTexGenf, GLenum, coord, d0, GLenum, pname, d1, GLfloat, param, fp0, \
  990.     , CYBERGL_BASE_NAME)
  991.  
  992. #define glTexGenfv(coord, pname, params) \
  993.     LP3NR(0x5ee, glTexGenfv, GLenum, coord, d0, GLenum, pname, d1, const GLfloat *, params, a0, \
  994.     , CYBERGL_BASE_NAME)
  995.  
  996. #define glTexGeni() \
  997.     LP0NR(0x5d6, glTexGeni, \
  998.     , CYBERGL_BASE_NAME)
  999.  
  1000. #define glTexGeniv(coord, pname, params) \
  1001.     LP3NR(0x5e8, glTexGeniv, GLenum, coord, d0, GLenum, pname, d1, const GLint *, params, a0, \
  1002.     , CYBERGL_BASE_NAME)
  1003.  
  1004. #define glTexImage1D(target, level, components, width, border, format, type, pixels) \
  1005.     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 void *, pixels, a0, \
  1006.     , CYBERGL_BASE_NAME)
  1007.  
  1008. #define glTexImage2D(target, level, components, width, height, border, format, type, pixels) \
  1009.     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 void *, pixels, a0, \
  1010.     , CYBERGL_BASE_NAME)
  1011.  
  1012. #define glTexParameterf(target, pname, param) \
  1013.     LP3NR(0x612, glTexParameterf, GLenum, target, d0, GLenum, pname, d1, GLfloat, param, fp0, \
  1014.     , CYBERGL_BASE_NAME)
  1015.  
  1016. #define glTexParameterfv(target, pname, params) \
  1017.     LP3NR(0x61e, glTexParameterfv, GLenum, target, d0, GLenum, pname, d1, const GLfloat *, params, a0, \
  1018.     , CYBERGL_BASE_NAME)
  1019.  
  1020. #define glTexParameteri(target, pname, param) \
  1021.     LP3NR(0x618, glTexParameteri, GLenum, target, d0, GLenum, pname, d1, GLint, param, d2, \
  1022.     , CYBERGL_BASE_NAME)
  1023.  
  1024. #define glTexParameteriv(target, pname, params) \
  1025.     LP3NR(0x624, glTexParameteriv, GLenum, target, d0, GLenum, pname, d1, const GLint *, params, a0, \
  1026.     , CYBERGL_BASE_NAME)
  1027.  
  1028. #define glTranslated(x, y, z) \
  1029.     LP3NR(0x4aa, glTranslated, GLdouble, x, fp0, GLdouble, y, fp1, GLdouble, z, fp2, \
  1030.     , CYBERGL_BASE_NAME)
  1031.  
  1032. #define glTranslatef(x, y, z) \
  1033.     LP3NR(0x4a4, glTranslatef, GLfloat, x, fp0, GLfloat, y, fp1, GLfloat, z, fp2, \
  1034.     , CYBERGL_BASE_NAME)
  1035.  
  1036. #define glUnProject(winx, winy, winz, objx, objy, objz) \
  1037.     LP6(0x4e0, GLboolean, glUnProject, GLdouble, winx, fp0, GLdouble, winy, fp1, GLdouble, winz, fp2, GLdouble *, objx, a0, GLdouble *, objy, a1, GLdouble *, objz, a2, \
  1038.     , CYBERGL_BASE_NAME)
  1039.  
  1040. #define glVertex2d(x, y) \
  1041.     LP2NR(0x132, glVertex2d, GLdouble, x, fp0, GLdouble, y, fp1, \
  1042.     , CYBERGL_BASE_NAME)
  1043.  
  1044. #define glVertex2dv(v) \
  1045.     LP1NR(0x17a, glVertex2dv, const GLdouble *, v, a0, \
  1046.     , CYBERGL_BASE_NAME)
  1047.  
  1048. #define glVertex2f(x, y) \
  1049.     LP2NR(0x12c, glVertex2f, GLfloat, x, fp0, GLfloat, y, fp1, \
  1050.     , CYBERGL_BASE_NAME)
  1051.  
  1052. #define glVertex2fv(v) \
  1053.     LP1NR(0x174, glVertex2fv, const GLfloat *, v, a0, \
  1054.     , CYBERGL_BASE_NAME)
  1055.  
  1056. #define glVertex2i(x, y) \
  1057.     LP2NR(0x126, glVertex2i, GLint, x, d0, GLint, y, d1, \
  1058.     , CYBERGL_BASE_NAME)
  1059.  
  1060. #define glVertex2iv(v) \
  1061.     LP1NR(0x16e, glVertex2iv, const GLint *, v, a0, \
  1062.     , CYBERGL_BASE_NAME)
  1063.  
  1064. #define glVertex2s(x, y) \
  1065.     LP2NR(0x120, glVertex2s, GLshort, x, d0, GLshort, y, d1, \
  1066.     , CYBERGL_BASE_NAME)
  1067.  
  1068. #define glVertex2sv(v) \
  1069.     LP1NR(0x168, glVertex2sv, const GLshort *, v, a0, \
  1070.     , CYBERGL_BASE_NAME)
  1071.  
  1072. #define glVertex3d(x, y, z) \
  1073.     LP3NR(0x14a, glVertex3d, GLdouble, x, fp0, GLdouble, y, fp1, GLdouble, z, fp2, \
  1074.     , CYBERGL_BASE_NAME)
  1075.  
  1076. #define glVertex3dv(v) \
  1077.     LP1NR(0x192, glVertex3dv, const GLdouble *, v, a0, \
  1078.     , CYBERGL_BASE_NAME)
  1079.  
  1080. #define glVertex3f(x, y, z) \
  1081.     LP3NR(0x144, glVertex3f, GLfloat, x, fp0, GLfloat, y, fp1, GLfloat, z, fp2, \
  1082.     , CYBERGL_BASE_NAME)
  1083.  
  1084. #define glVertex3fv(v) \
  1085.     LP1NR(0x18c, glVertex3fv, const GLfloat *, v, a0, \
  1086.     , CYBERGL_BASE_NAME)
  1087.  
  1088. #define glVertex3i(x, y, z) \
  1089.     LP3NR(0x13e, glVertex3i, GLint, x, d0, GLint, y, d1, GLint, z, d2, \
  1090.     , CYBERGL_BASE_NAME)
  1091.  
  1092. #define glVertex3iv(v) \
  1093.     LP1NR(0x186, glVertex3iv, const GLint *, v, a0, \
  1094.     , CYBERGL_BASE_NAME)
  1095.  
  1096. #define glVertex3s(x, y, z) \
  1097.     LP3NR(0x138, glVertex3s, GLshort, x, d0, GLshort, y, d1, GLshort, z, d2, \
  1098.     , CYBERGL_BASE_NAME)
  1099.  
  1100. #define glVertex3sv(v) \
  1101.     LP1NR(0x180, glVertex3sv, const GLshort *, v, a0, \
  1102.     , CYBERGL_BASE_NAME)
  1103.  
  1104. #define glVertex4d(x, y, z, w) \
  1105.     LP4NR(0x162, glVertex4d, GLdouble, x, fp0, GLdouble, y, fp1, GLdouble, z, fp2, GLdouble, w, fp3, \
  1106.     , CYBERGL_BASE_NAME)
  1107.  
  1108. #define glVertex4dv(v) \
  1109.     LP1NR(0x1aa, glVertex4dv, const GLdouble *, v, a0, \
  1110.     , CYBERGL_BASE_NAME)
  1111.  
  1112. #define glVertex4f(x, y, z, w) \
  1113.     LP4NR(0x15c, glVertex4f, GLfloat, x, fp0, GLfloat, y, fp1, GLfloat, z, fp2, GLfloat, w, fp3, \
  1114.     , CYBERGL_BASE_NAME)
  1115.  
  1116. #define glVertex4fv(v) \
  1117.     LP1NR(0x1a4, glVertex4fv, const GLfloat *, v, a0, \
  1118.     , CYBERGL_BASE_NAME)
  1119.  
  1120. #define glVertex4i(x, y, z, w) \
  1121.     LP4NR(0x156, glVertex4i, GLint, x, d0, GLint, y, d1, GLint, z, d2, GLint, w, d3, \
  1122.     , CYBERGL_BASE_NAME)
  1123.  
  1124. #define glVertex4iv(v) \
  1125.     LP1NR(0x19e, glVertex4iv, const GLint *, v, a0, \
  1126.     , CYBERGL_BASE_NAME)
  1127.  
  1128. #define glVertex4s(x, y, z, w) \
  1129.     LP4NR(0x150, glVertex4s, GLshort, x, d0, GLshort, y, d1, GLshort, z, d2, GLshort, w, d3, \
  1130.     , CYBERGL_BASE_NAME)
  1131.  
  1132. #define glVertex4sv(v) \
  1133.     LP1NR(0x198, glVertex4sv, const GLshort *, v, a0, \
  1134.     , CYBERGL_BASE_NAME)
  1135.  
  1136. #define glViewport(x, y, width, height) \
  1137.     LP4NR(0x46e, glViewport, GLint, x, d0, GLint, y, d1, GLsizei, width, d2, GLsizei, height, d3, \
  1138.     , CYBERGL_BASE_NAME)
  1139.  
  1140. #define openGLWindowTagList(width, height, tags) \
  1141.     LP3(0x1e, void *, openGLWindowTagList, GLint, width, d0, GLint, height, d1, struct TagItem *, tags, a0, \
  1142.     , CYBERGL_BASE_NAME)
  1143.  
  1144. #ifndef NO_INLINE_STDARG
  1145. #define openGLWindowTags(a0, a1, tags...) \
  1146.     ({ULONG _tags[] = { tags }; openGLWindowTagList((a0), (a1), (struct TagItem *)_tags);})
  1147. #endif /* !NO_INLINE_STDARG */
  1148.  
  1149. #define resizeGLWindow(window, width, height) \
  1150.     LP3NR(0x36, resizeGLWindow, void *, window, a0, GLint, width, d0, GLint, height, d1, \
  1151.     , CYBERGL_BASE_NAME)
  1152.  
  1153. #endif /* !_INLINE_CYBERGL_H */
  1154.