1 /* gl.c: s7, Ruby, and Forth bindings for GL, GLU 2 * generated automatically from makegl.scm and gldata.scm 3 * needs xen.h 4 * 5 * reference args are ignored if passed, resultant values are returned in a list. 6 * the various "v" forms are omitted for now -- are they needed in this context? 7 * 'gl is added to *features* 8 * 9 * HISTORY: 10 * 11 * 16-Apr-14: changed max-args to 8. 12 * -------- 13 * 16-Dec-09: removed Guile support. 14 * -------- 15 * 17-Oct-08: removed gtkglext bindings. 16 * -------- 17 * 30-Mar-06: check for glu.h, omit GLU_* if necessary. Add Forth support. 18 * -------- 19 * 13-Jun-05: merged gl-ruby.c into gl.c. 20 * -------- 21 * 10-Mar: Gl_Version. 22 * 1-Feb-03: glGet* funcs now try to handle multiple return values correctly. 23 * -------- 24 * 18-Nov: added more GtkGlext bindings. 25 * 1-Aug: removed all 'EXT' junk. 26 * 24-July: changed Guile prefix (R5RS reserves vertical-bar). 27 * 18-June: GL 1.1 stubs. 28 * 4-June: GtkGLext support. 29 * 20-May-02: initial version. 30 */ 31 32 #include "mus-config.h" 33 34 #if HAVE_EXTENSION_LANGUAGE 35 #include <GL/gl.h> 36 #if HAVE_GLU 37 #include <GL/glu.h> 38 #endif 39 #if USE_MOTIF 40 #include <GL/glx.h> 41 #endif 42 #include <string.h> 43 44 #if USE_SND 45 /* USE_SND causes xm to use Snd's error handlers which are much smarter than xen's fallback versions */ 46 #include "snd.h" 47 #else 48 #include "xen.h" 49 #endif 50 #ifndef unsigned_long 51 /* for FreeBSD (thanks to Michael Scholz) (can't use ulong here due to collisions elsewhere) */ 52 typedef unsigned long unsigned_long; 53 #endif 54 55 /* prefix for all names */ 56 #if HAVE_SCHEME 57 #define XL_PRE "" 58 #define XL_POST "" 59 #endif 60 #if HAVE_RUBY 61 /* for Ruby, XG PRE needs to be uppercase */ 62 #define XL_PRE "R" 63 #define XL_POST "" 64 #endif 65 #if HAVE_FORTH 66 #define XL_PRE "F" 67 #define XL_POST "" 68 #endif 69 70 #define wrap_for_Xen(Name, Value) Xen_list_2(C_string_to_Xen_symbol(Name), Xen_wrap_C_pointer(Value)) 71 #define is_wrapped(Name, Value) (Xen_is_list(Value) && \ 72 (Xen_list_length(Value) >= 2) && \ 73 (Xen_is_symbol(Xen_car(Value))) && \ 74 (strcmp(Name, Xen_symbol_to_C_string(Xen_car(Value))) == 0)) 75 76 #define XL_TYPE(Name, XType) \ 77 static Xen C_to_Xen_ ## Name (XType val) {return(Xen_list_2(C_string_to_Xen_symbol(#Name), C_ulong_to_Xen_ulong(val)));} \ 78 static XType Xen_to_C_ ## Name (Xen val) {return((XType)Xen_ulong_to_C_ulong(Xen_cadr(val)));} \ 79 static bool Xen_is_ ## Name (Xen val) {return(is_wrapped(#Name, val));} 80 #define XL_TYPE_1(Name, XType) \ 81 static XType Xen_to_C_ ## Name (Xen val) {return((XType)Xen_ulong_to_C_ulong(Xen_cadr(val)));} \ 82 static bool Xen_is_ ## Name (Xen val) {return(is_wrapped(#Name, val));} 83 84 #define XL_TYPE_PTR(Name, XType) \ 85 static Xen C_to_Xen_ ## Name (XType val) {if (val) return(wrap_for_Xen(#Name, val)); return(Xen_false);} \ 86 static XType Xen_to_C_ ## Name (Xen val) {if (Xen_is_false(val)) return(NULL); return((XType)Xen_unwrap_C_pointer(Xen_cadr(val)));} \ 87 static bool Xen_is_ ## Name (Xen val) {return(is_wrapped(#Name, val));} /* if NULL ok, should be explicit */ 88 #define XL_TYPE_PTR_1(Name, XType) \ 89 static XType Xen_to_C_ ## Name (Xen val) {if (Xen_is_false(val)) return(NULL); return((XType)Xen_unwrap_C_pointer(Xen_cadr(val)));} \ 90 static bool Xen_is_ ## Name (Xen val) {return(is_wrapped(#Name, val));} /* if NULL ok, should be explicit */ 91 92 93 /* ---------------------------------------- types ---------------------------------------- */ 94 95 #if USE_MOTIF 96 XL_TYPE_PTR(XVisualInfo, XVisualInfo*) 97 XL_TYPE_PTR(Display, Display*) 98 #define C_to_Xen_int(Arg) C_int_to_Xen_integer(Arg) 99 #define Xen_to_C_int(Arg) (int)(Xen_integer_to_C_int(Arg)) 100 #define Xen_is_int(Arg) Xen_is_integer(Arg) 101 XL_TYPE_PTR_1(int_, int*) 102 XL_TYPE_PTR(GLXContext, GLXContext) 103 #define Xen_to_C_unsigned_long(Arg) (unsigned_long)(Xen_ulong_to_C_ulong(Arg)) 104 #define Xen_is_unsigned_long(Arg) Xen_is_ulong(Arg) 105 #define C_to_Xen_Bool(Arg) C_bool_to_Xen_boolean(Arg) 106 #define Xen_to_C_Bool(Arg) (Bool)(Xen_boolean_to_C_bool(Arg)) 107 #define Xen_is_Bool(Arg) Xen_is_boolean(Arg) 108 XL_TYPE(GLXPixmap, GLXPixmap) 109 XL_TYPE_1(Pixmap, Pixmap) 110 XL_TYPE(Window, Window) 111 XL_TYPE_1(Font, Font) 112 #define C_to_Xen_char_(Arg) C_string_to_Xen_string(Arg) 113 #define Xen_to_C_char_(Arg) (char*)(Xen_string_to_C_string(Arg)) 114 #define Xen_is_char_(Arg) Xen_is_string(Arg) 115 #endif 116 #define C_to_Xen_GLfloat(Arg) C_double_to_Xen_real(Arg) 117 #define Xen_to_C_GLfloat(Arg) (GLfloat)(Xen_real_to_C_double(Arg)) 118 #define Xen_is_GLfloat(Arg) Xen_is_number(Arg) 119 #define Xen_to_C_GLclampf(Arg) (GLclampf)(Xen_real_to_C_double(Arg)) 120 #define Xen_is_GLclampf(Arg) Xen_is_number(Arg) 121 #define Xen_to_C_GLbitfield(Arg) (GLbitfield)(Xen_ulong_to_C_ulong(Arg)) 122 #define Xen_is_GLbitfield(Arg) Xen_is_ulong(Arg) 123 #define C_to_Xen_GLuint(Arg) C_ulong_to_Xen_ulong(Arg) 124 #define Xen_to_C_GLuint(Arg) (GLuint)(Xen_ulong_to_C_ulong(Arg)) 125 #define Xen_is_GLuint(Arg) Xen_is_ulong(Arg) 126 #define C_to_Xen_GLboolean(Arg) C_bool_to_Xen_boolean(Arg) 127 #define Xen_to_C_GLboolean(Arg) (GLboolean)(Xen_boolean_to_C_bool(Arg)) 128 #define Xen_is_GLboolean(Arg) Xen_is_boolean(Arg) 129 #define C_to_Xen_GLenum(Arg) C_int_to_Xen_integer(Arg) 130 #define Xen_to_C_GLenum(Arg) (GLenum)(Xen_integer_to_C_int(Arg)) 131 #define Xen_is_GLenum(Arg) Xen_is_integer(Arg) 132 #define C_to_Xen_GLint(Arg) C_int_to_Xen_integer(Arg) 133 #define Xen_to_C_GLint(Arg) (GLint)(Xen_integer_to_C_int(Arg)) 134 #define Xen_is_GLint(Arg) Xen_is_integer(Arg) 135 #define C_to_Xen_GLushort(Arg) C_int_to_Xen_integer(Arg) 136 #define Xen_to_C_GLushort(Arg) (GLushort)(Xen_integer_to_C_int(Arg)) 137 #define Xen_is_GLushort(Arg) Xen_is_integer(Arg) 138 XL_TYPE_PTR_1(GLubyte_, GLubyte*) 139 #define Xen_to_C_GLsizei(Arg) (GLsizei)(Xen_integer_to_C_int(Arg)) 140 #define Xen_is_GLsizei(Arg) Xen_is_integer(Arg) 141 XL_TYPE_PTR_1(GLdouble_, GLdouble*) 142 #define C_to_Xen_GLdouble(Arg) C_double_to_Xen_real(Arg) 143 #define Xen_to_C_GLdouble(Arg) (GLdouble)(Xen_real_to_C_double(Arg)) 144 #define Xen_is_GLdouble(Arg) Xen_is_number(Arg) 145 #define C_to_Xen_constchar_(Arg) C_string_to_Xen_string((char *)(Arg)) 146 #define Xen_to_C_GLclampd(Arg) (GLclampd)(Xen_real_to_C_double(Arg)) 147 #define Xen_is_GLclampd(Arg) Xen_is_number(Arg) 148 XL_TYPE_PTR_1(GLfloat_, GLfloat*) 149 XL_TYPE_PTR_1(GLvoid_, GLvoid*) 150 #define Xen_to_C_GLshort(Arg) (GLshort)(Xen_integer_to_C_int(Arg)) 151 #define Xen_is_GLshort(Arg) Xen_is_integer(Arg) 152 #define Xen_to_C_GLbyte(Arg) (GLbyte)(Xen_integer_to_C_int(Arg)) 153 #define Xen_is_GLbyte(Arg) Xen_is_integer(Arg) 154 #define C_to_Xen_GLubyte(Arg) C_int_to_Xen_integer(Arg) 155 #define Xen_to_C_GLubyte(Arg) (GLubyte)(Xen_integer_to_C_int(Arg)) 156 #define Xen_is_GLubyte(Arg) Xen_is_integer(Arg) 157 XL_TYPE_PTR(void_, void*) 158 XL_TYPE_PTR_1(GLuint_, GLuint*) 159 XL_TYPE_PTR_1(GLboolean_, GLboolean*) 160 #if HAVE_GLU 161 XL_TYPE_PTR(GLUnurbs_, GLUnurbs*) 162 #endif 163 #ifdef GLU_VERSION_1_2 164 XL_TYPE_PTR(GLUtesselator_, GLUtesselator*) 165 #endif 166 #if HAVE_GLU 167 XL_TYPE_PTR(GLUquadric_, GLUquadric*) 168 #endif 169 XL_TYPE_PTR_1(GLint_, GLint*) 170 #if HAVE_GLU 171 XL_TYPE(_GLUfuncptr, _GLUfuncptr) 172 #endif 173 174 175 /* ---------------------------------------- state readback confusion ---------------------------------------- */ 176 177 static int how_many_vals(GLenum gl) 178 { 179 switch (gl) 180 { 181 case GL_CURRENT_COLOR: 182 case GL_CURRENT_TEXTURE_COORDS: 183 case GL_CURRENT_RASTER_POSITION: 184 case GL_CURRENT_RASTER_COLOR: 185 case GL_CURRENT_RASTER_TEXTURE_COORDS: 186 case GL_VIEWPORT: 187 case GL_FOG_COLOR: 188 case GL_AMBIENT: 189 case GL_DIFFUSE: 190 case GL_SPECULAR: 191 case GL_EMISSION: 192 case GL_LIGHT_MODEL_AMBIENT: 193 case GL_SCISSOR_BOX: 194 case GL_COLOR_WRITEMASK: 195 case GL_COLOR_CLEAR_VALUE: 196 return(4); 197 break; 198 case GL_MODELVIEW_MATRIX: 199 case GL_PROJECTION_MATRIX: 200 case GL_TEXTURE_MATRIX: 201 return(16); 202 break; 203 case GL_CURRENT_NORMAL: 204 case GL_SPOT_DIRECTION: 205 return(3); 206 break; 207 case GL_DEPTH_RANGE: 208 case GL_LINE_WIDTH_RANGE: 209 return(2); 210 break; 211 default: return(1); break; /* try to squelch c++ babbling */ 212 } 213 return(1); 214 } 215 216 217 /* ---------------------------------------- functions ---------------------------------------- */ 218 219 #if USE_MOTIF 220 static Xen gxg_glXChooseVisual(Xen dpy, Xen screen, Xen attribList) 221 { 222 #define H_glXChooseVisual "XVisualInfo* glXChooseVisual(Display* dpy, int screen, int* attribList)" 223 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXChooseVisual", "Display*"); 224 Xen_check_type(Xen_is_int(screen), screen, 2, "glXChooseVisual", "int"); 225 Xen_check_type(Xen_is_int_(attribList), attribList, 3, "glXChooseVisual", "int*"); 226 return(C_to_Xen_XVisualInfo(glXChooseVisual(Xen_to_C_Display(dpy), Xen_to_C_int(screen), Xen_to_C_int_(attribList)))); 227 } 228 229 static Xen gxg_glXCopyContext(Xen dpy, Xen src, Xen dst, Xen mask) 230 { 231 #define H_glXCopyContext "void glXCopyContext(Display* dpy, GLXContext src, GLXContext dst, unsigned_long mask)" 232 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXCopyContext", "Display*"); 233 Xen_check_type(Xen_is_GLXContext(src), src, 2, "glXCopyContext", "GLXContext"); 234 Xen_check_type(Xen_is_GLXContext(dst), dst, 3, "glXCopyContext", "GLXContext"); 235 Xen_check_type(Xen_is_unsigned_long(mask), mask, 4, "glXCopyContext", "unsigned_long"); 236 glXCopyContext(Xen_to_C_Display(dpy), Xen_to_C_GLXContext(src), Xen_to_C_GLXContext(dst), Xen_to_C_unsigned_long(mask)); 237 return(Xen_false); 238 } 239 240 static Xen gxg_glXCreateContext(Xen dpy, Xen vis, Xen shareList, Xen direct) 241 { 242 #define H_glXCreateContext "GLXContext glXCreateContext(Display* dpy, XVisualInfo* vis, GLXContext shareList, \ 243 Bool direct)" 244 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXCreateContext", "Display*"); 245 Xen_check_type(Xen_is_XVisualInfo(vis), vis, 2, "glXCreateContext", "XVisualInfo*"); 246 Xen_check_type(Xen_is_GLXContext(shareList), shareList, 3, "glXCreateContext", "GLXContext"); 247 Xen_check_type(Xen_is_Bool(direct), direct, 4, "glXCreateContext", "Bool"); 248 return(C_to_Xen_GLXContext(glXCreateContext(Xen_to_C_Display(dpy), Xen_to_C_XVisualInfo(vis), Xen_to_C_GLXContext(shareList), 249 Xen_to_C_Bool(direct)))); 250 } 251 252 static Xen gxg_glXCreateGLXPixmap(Xen dpy, Xen vis, Xen pixmap) 253 { 254 #define H_glXCreateGLXPixmap "GLXPixmap glXCreateGLXPixmap(Display* dpy, XVisualInfo* vis, Pixmap pixmap)" 255 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXCreateGLXPixmap", "Display*"); 256 Xen_check_type(Xen_is_XVisualInfo(vis), vis, 2, "glXCreateGLXPixmap", "XVisualInfo*"); 257 Xen_check_type(Xen_is_Pixmap(pixmap), pixmap, 3, "glXCreateGLXPixmap", "Pixmap"); 258 return(C_to_Xen_GLXPixmap(glXCreateGLXPixmap(Xen_to_C_Display(dpy), Xen_to_C_XVisualInfo(vis), Xen_to_C_Pixmap(pixmap)))); 259 } 260 261 static Xen gxg_glXDestroyContext(Xen dpy, Xen ctx) 262 { 263 #define H_glXDestroyContext "void glXDestroyContext(Display* dpy, GLXContext ctx)" 264 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXDestroyContext", "Display*"); 265 Xen_check_type(Xen_is_GLXContext(ctx), ctx, 2, "glXDestroyContext", "GLXContext"); 266 glXDestroyContext(Xen_to_C_Display(dpy), Xen_to_C_GLXContext(ctx)); 267 return(Xen_false); 268 } 269 270 static Xen gxg_glXDestroyGLXPixmap(Xen dpy, Xen pix) 271 { 272 #define H_glXDestroyGLXPixmap "void glXDestroyGLXPixmap(Display* dpy, GLXPixmap pix)" 273 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXDestroyGLXPixmap", "Display*"); 274 Xen_check_type(Xen_is_GLXPixmap(pix), pix, 2, "glXDestroyGLXPixmap", "GLXPixmap"); 275 glXDestroyGLXPixmap(Xen_to_C_Display(dpy), Xen_to_C_GLXPixmap(pix)); 276 return(Xen_false); 277 } 278 279 static Xen gxg_glXGetConfig(Xen dpy, Xen vis, Xen attrib, Xen value) 280 { 281 #define H_glXGetConfig "int glXGetConfig(Display* dpy, XVisualInfo* vis, int attrib, int* [value])" 282 int ref_value[1]; 283 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXGetConfig", "Display*"); 284 Xen_check_type(Xen_is_XVisualInfo(vis), vis, 2, "glXGetConfig", "XVisualInfo*"); 285 Xen_check_type(Xen_is_int(attrib), attrib, 3, "glXGetConfig", "int"); 286 { 287 Xen result; 288 result = C_to_Xen_int(glXGetConfig(Xen_to_C_Display(dpy), Xen_to_C_XVisualInfo(vis), Xen_to_C_int(attrib), ref_value)); 289 return(Xen_list_2(result, C_to_Xen_int(ref_value[0]))); 290 } 291 } 292 293 static Xen gxg_glXGetCurrentContext(void) 294 { 295 #define H_glXGetCurrentContext "GLXContext glXGetCurrentContext( void)" 296 return(C_to_Xen_GLXContext(glXGetCurrentContext())); 297 } 298 299 static Xen gxg_glXGetCurrentDrawable(void) 300 { 301 #define H_glXGetCurrentDrawable "Window glXGetCurrentDrawable( void)" 302 return(C_to_Xen_Window(glXGetCurrentDrawable())); 303 } 304 305 static Xen gxg_glXIsDirect(Xen dpy, Xen ctx) 306 { 307 #define H_glXIsDirect "Bool glXIsDirect(Display* dpy, GLXContext ctx)" 308 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXIsDirect", "Display*"); 309 Xen_check_type(Xen_is_GLXContext(ctx), ctx, 2, "glXIsDirect", "GLXContext"); 310 return(C_to_Xen_Bool(glXIsDirect(Xen_to_C_Display(dpy), Xen_to_C_GLXContext(ctx)))); 311 } 312 313 static Xen gxg_glXMakeCurrent(Xen dpy, Xen drawable, Xen ctx) 314 { 315 #define H_glXMakeCurrent "Bool glXMakeCurrent(Display* dpy, Window drawable, GLXContext ctx)" 316 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXMakeCurrent", "Display*"); 317 Xen_check_type(Xen_is_Window(drawable), drawable, 2, "glXMakeCurrent", "Window"); 318 Xen_check_type(Xen_is_GLXContext(ctx), ctx, 3, "glXMakeCurrent", "GLXContext"); 319 return(C_to_Xen_Bool(glXMakeCurrent(Xen_to_C_Display(dpy), Xen_to_C_Window(drawable), Xen_to_C_GLXContext(ctx)))); 320 } 321 322 static Xen gxg_glXQueryExtension(Xen dpy, Xen errorBase, Xen eventBase) 323 { 324 #define H_glXQueryExtension "Bool glXQueryExtension(Display* dpy, int* [errorBase], int* [eventBase])" 325 int ref_errorBase[1]; 326 int ref_eventBase[1]; 327 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXQueryExtension", "Display*"); 328 { 329 Xen result; 330 result = C_to_Xen_Bool(glXQueryExtension(Xen_to_C_Display(dpy), ref_errorBase, ref_eventBase)); 331 return(Xen_list_3(result, C_to_Xen_int(ref_errorBase[0]), C_to_Xen_int(ref_eventBase[0]))); 332 } 333 } 334 335 static Xen gxg_glXQueryVersion(Xen dpy, Xen major, Xen minor) 336 { 337 #define H_glXQueryVersion "Bool glXQueryVersion(Display* dpy, int* [major], int* [minor])" 338 int ref_major[1]; 339 int ref_minor[1]; 340 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXQueryVersion", "Display*"); 341 { 342 Xen result; 343 result = C_to_Xen_Bool(glXQueryVersion(Xen_to_C_Display(dpy), ref_major, ref_minor)); 344 return(Xen_list_3(result, C_to_Xen_int(ref_major[0]), C_to_Xen_int(ref_minor[0]))); 345 } 346 } 347 348 static Xen gxg_glXSwapBuffers(Xen dpy, Xen drawable) 349 { 350 #define H_glXSwapBuffers "void glXSwapBuffers(Display* dpy, Window drawable)" 351 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXSwapBuffers", "Display*"); 352 Xen_check_type(Xen_is_Window(drawable), drawable, 2, "glXSwapBuffers", "Window"); 353 glXSwapBuffers(Xen_to_C_Display(dpy), Xen_to_C_Window(drawable)); 354 return(Xen_false); 355 } 356 357 static Xen gxg_glXUseXFont(Xen font, Xen first, Xen count, Xen listBase) 358 { 359 #define H_glXUseXFont "void glXUseXFont(Font font, int first, int count, int listBase)" 360 Xen_check_type(Xen_is_Font(font), font, 1, "glXUseXFont", "Font"); 361 Xen_check_type(Xen_is_int(first), first, 2, "glXUseXFont", "int"); 362 Xen_check_type(Xen_is_int(count), count, 3, "glXUseXFont", "int"); 363 Xen_check_type(Xen_is_int(listBase), listBase, 4, "glXUseXFont", "int"); 364 glXUseXFont(Xen_to_C_Font(font), Xen_to_C_int(first), Xen_to_C_int(count), Xen_to_C_int(listBase)); 365 return(Xen_false); 366 } 367 368 static Xen gxg_glXWaitGL(void) 369 { 370 #define H_glXWaitGL "void glXWaitGL( void)" 371 glXWaitGL(); 372 return(Xen_false); 373 } 374 375 static Xen gxg_glXWaitX(void) 376 { 377 #define H_glXWaitX "void glXWaitX( void)" 378 glXWaitX(); 379 return(Xen_false); 380 } 381 382 static Xen gxg_glXGetClientString(Xen dpy, Xen name) 383 { 384 #define H_glXGetClientString "char* glXGetClientString(Display* dpy, int name)" 385 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXGetClientString", "Display*"); 386 Xen_check_type(Xen_is_int(name), name, 2, "glXGetClientString", "int"); 387 return(C_to_Xen_char_(glXGetClientString(Xen_to_C_Display(dpy), Xen_to_C_int(name)))); 388 } 389 390 static Xen gxg_glXQueryServerString(Xen dpy, Xen screen, Xen name) 391 { 392 #define H_glXQueryServerString "char* glXQueryServerString(Display* dpy, int screen, int name)" 393 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXQueryServerString", "Display*"); 394 Xen_check_type(Xen_is_int(screen), screen, 2, "glXQueryServerString", "int"); 395 Xen_check_type(Xen_is_int(name), name, 3, "glXQueryServerString", "int"); 396 return(C_to_Xen_char_(glXQueryServerString(Xen_to_C_Display(dpy), Xen_to_C_int(screen), Xen_to_C_int(name)))); 397 } 398 399 static Xen gxg_glXQueryExtensionsString(Xen dpy, Xen screen) 400 { 401 #define H_glXQueryExtensionsString "char* glXQueryExtensionsString(Display* dpy, int screen)" 402 Xen_check_type(Xen_is_Display(dpy), dpy, 1, "glXQueryExtensionsString", "Display*"); 403 Xen_check_type(Xen_is_int(screen), screen, 2, "glXQueryExtensionsString", "int"); 404 return(C_to_Xen_char_(glXQueryExtensionsString(Xen_to_C_Display(dpy), Xen_to_C_int(screen)))); 405 } 406 407 #endif 408 static Xen gxg_glClearIndex(Xen c) 409 { 410 #define H_glClearIndex "void glClearIndex(GLfloat c)" 411 Xen_check_type(Xen_is_GLfloat(c), c, 1, "glClearIndex", "GLfloat"); 412 glClearIndex(Xen_to_C_GLfloat(c)); 413 return(Xen_false); 414 } 415 416 static Xen gxg_glClearColor(Xen red, Xen green, Xen blue, Xen alpha) 417 { 418 #define H_glClearColor "void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)" 419 Xen_check_type(Xen_is_GLclampf(red), red, 1, "glClearColor", "GLclampf"); 420 Xen_check_type(Xen_is_GLclampf(green), green, 2, "glClearColor", "GLclampf"); 421 Xen_check_type(Xen_is_GLclampf(blue), blue, 3, "glClearColor", "GLclampf"); 422 Xen_check_type(Xen_is_GLclampf(alpha), alpha, 4, "glClearColor", "GLclampf"); 423 glClearColor(Xen_to_C_GLclampf(red), Xen_to_C_GLclampf(green), Xen_to_C_GLclampf(blue), Xen_to_C_GLclampf(alpha)); 424 return(Xen_false); 425 } 426 427 static Xen gxg_glClear(Xen mask) 428 { 429 #define H_glClear "void glClear(GLbitfield mask)" 430 Xen_check_type(Xen_is_GLbitfield(mask), mask, 1, "glClear", "GLbitfield"); 431 glClear(Xen_to_C_GLbitfield(mask)); 432 return(Xen_false); 433 } 434 435 static Xen gxg_glIndexMask(Xen mask) 436 { 437 #define H_glIndexMask "void glIndexMask(GLuint mask)" 438 Xen_check_type(Xen_is_GLuint(mask), mask, 1, "glIndexMask", "GLuint"); 439 glIndexMask(Xen_to_C_GLuint(mask)); 440 return(Xen_false); 441 } 442 443 static Xen gxg_glColorMask(Xen red, Xen green, Xen blue, Xen alpha) 444 { 445 #define H_glColorMask "void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)" 446 Xen_check_type(Xen_is_GLboolean(red), red, 1, "glColorMask", "GLboolean"); 447 Xen_check_type(Xen_is_GLboolean(green), green, 2, "glColorMask", "GLboolean"); 448 Xen_check_type(Xen_is_GLboolean(blue), blue, 3, "glColorMask", "GLboolean"); 449 Xen_check_type(Xen_is_GLboolean(alpha), alpha, 4, "glColorMask", "GLboolean"); 450 glColorMask(Xen_to_C_GLboolean(red), Xen_to_C_GLboolean(green), Xen_to_C_GLboolean(blue), Xen_to_C_GLboolean(alpha)); 451 return(Xen_false); 452 } 453 454 static Xen gxg_glAlphaFunc(Xen func, Xen ref) 455 { 456 #define H_glAlphaFunc "void glAlphaFunc(GLenum func, GLclampf ref)" 457 Xen_check_type(Xen_is_GLenum(func), func, 1, "glAlphaFunc", "GLenum"); 458 Xen_check_type(Xen_is_GLclampf(ref), ref, 2, "glAlphaFunc", "GLclampf"); 459 glAlphaFunc(Xen_to_C_GLenum(func), Xen_to_C_GLclampf(ref)); 460 return(Xen_false); 461 } 462 463 static Xen gxg_glBlendFunc(Xen sfactor, Xen dfactor) 464 { 465 #define H_glBlendFunc "void glBlendFunc(GLenum sfactor, GLenum dfactor)" 466 Xen_check_type(Xen_is_GLenum(sfactor), sfactor, 1, "glBlendFunc", "GLenum"); 467 Xen_check_type(Xen_is_GLenum(dfactor), dfactor, 2, "glBlendFunc", "GLenum"); 468 glBlendFunc(Xen_to_C_GLenum(sfactor), Xen_to_C_GLenum(dfactor)); 469 return(Xen_false); 470 } 471 472 static Xen gxg_glLogicOp(Xen opcode) 473 { 474 #define H_glLogicOp "void glLogicOp(GLenum opcode)" 475 Xen_check_type(Xen_is_GLenum(opcode), opcode, 1, "glLogicOp", "GLenum"); 476 glLogicOp(Xen_to_C_GLenum(opcode)); 477 return(Xen_false); 478 } 479 480 static Xen gxg_glCullFace(Xen mode) 481 { 482 #define H_glCullFace "void glCullFace(GLenum mode)" 483 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glCullFace", "GLenum"); 484 glCullFace(Xen_to_C_GLenum(mode)); 485 return(Xen_false); 486 } 487 488 static Xen gxg_glFrontFace(Xen mode) 489 { 490 #define H_glFrontFace "void glFrontFace(GLenum mode)" 491 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glFrontFace", "GLenum"); 492 glFrontFace(Xen_to_C_GLenum(mode)); 493 return(Xen_false); 494 } 495 496 static Xen gxg_glPointSize(Xen size) 497 { 498 #define H_glPointSize "void glPointSize(GLfloat size)" 499 Xen_check_type(Xen_is_GLfloat(size), size, 1, "glPointSize", "GLfloat"); 500 glPointSize(Xen_to_C_GLfloat(size)); 501 return(Xen_false); 502 } 503 504 static Xen gxg_glLineWidth(Xen width) 505 { 506 #define H_glLineWidth "void glLineWidth(GLfloat width)" 507 Xen_check_type(Xen_is_GLfloat(width), width, 1, "glLineWidth", "GLfloat"); 508 glLineWidth(Xen_to_C_GLfloat(width)); 509 return(Xen_false); 510 } 511 512 static Xen gxg_glLineStipple(Xen factor, Xen pattern) 513 { 514 #define H_glLineStipple "void glLineStipple(GLint factor, GLushort pattern)" 515 Xen_check_type(Xen_is_GLint(factor), factor, 1, "glLineStipple", "GLint"); 516 Xen_check_type(Xen_is_GLushort(pattern), pattern, 2, "glLineStipple", "GLushort"); 517 glLineStipple(Xen_to_C_GLint(factor), Xen_to_C_GLushort(pattern)); 518 return(Xen_false); 519 } 520 521 static Xen gxg_glPolygonMode(Xen face, Xen mode) 522 { 523 #define H_glPolygonMode "void glPolygonMode(GLenum face, GLenum mode)" 524 Xen_check_type(Xen_is_GLenum(face), face, 1, "glPolygonMode", "GLenum"); 525 Xen_check_type(Xen_is_GLenum(mode), mode, 2, "glPolygonMode", "GLenum"); 526 glPolygonMode(Xen_to_C_GLenum(face), Xen_to_C_GLenum(mode)); 527 return(Xen_false); 528 } 529 530 static Xen gxg_glPolygonOffset(Xen factor, Xen units) 531 { 532 #define H_glPolygonOffset "void glPolygonOffset(GLfloat factor, GLfloat units)" 533 Xen_check_type(Xen_is_GLfloat(factor), factor, 1, "glPolygonOffset", "GLfloat"); 534 Xen_check_type(Xen_is_GLfloat(units), units, 2, "glPolygonOffset", "GLfloat"); 535 glPolygonOffset(Xen_to_C_GLfloat(factor), Xen_to_C_GLfloat(units)); 536 return(Xen_false); 537 } 538 539 static Xen gxg_glPolygonStipple(Xen mask) 540 { 541 #define H_glPolygonStipple "void glPolygonStipple(GLubyte* mask)" 542 Xen_check_type(Xen_is_GLubyte_(mask), mask, 1, "glPolygonStipple", "GLubyte*"); 543 glPolygonStipple(Xen_to_C_GLubyte_(mask)); 544 return(Xen_false); 545 } 546 547 static Xen gxg_glEdgeFlag(Xen flag) 548 { 549 #define H_glEdgeFlag "void glEdgeFlag(GLboolean flag)" 550 Xen_check_type(Xen_is_GLboolean(flag), flag, 1, "glEdgeFlag", "GLboolean"); 551 glEdgeFlag(Xen_to_C_GLboolean(flag)); 552 return(Xen_false); 553 } 554 555 static Xen gxg_glScissor(Xen x, Xen y, Xen width, Xen height) 556 { 557 #define H_glScissor "void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)" 558 Xen_check_type(Xen_is_GLint(x), x, 1, "glScissor", "GLint"); 559 Xen_check_type(Xen_is_GLint(y), y, 2, "glScissor", "GLint"); 560 Xen_check_type(Xen_is_GLsizei(width), width, 3, "glScissor", "GLsizei"); 561 Xen_check_type(Xen_is_GLsizei(height), height, 4, "glScissor", "GLsizei"); 562 glScissor(Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height)); 563 return(Xen_false); 564 } 565 566 static Xen gxg_glClipPlane(Xen plane, Xen equation) 567 { 568 #define H_glClipPlane "void glClipPlane(GLenum plane, GLdouble* equation)" 569 Xen_check_type(Xen_is_GLenum(plane), plane, 1, "glClipPlane", "GLenum"); 570 Xen_check_type(Xen_is_GLdouble_(equation), equation, 2, "glClipPlane", "GLdouble*"); 571 glClipPlane(Xen_to_C_GLenum(plane), Xen_to_C_GLdouble_(equation)); 572 return(Xen_false); 573 } 574 575 static Xen gxg_glGetClipPlane(Xen plane, Xen equation) 576 { 577 #define H_glGetClipPlane "void glGetClipPlane(GLenum plane, GLdouble* [equation])" 578 GLdouble ref_equation[1]; 579 Xen_check_type(Xen_is_GLenum(plane), plane, 1, "glGetClipPlane", "GLenum"); 580 glGetClipPlane(Xen_to_C_GLenum(plane), ref_equation); 581 return(Xen_list_1(C_to_Xen_GLdouble(ref_equation[0]))); 582 } 583 584 static Xen gxg_glDrawBuffer(Xen mode) 585 { 586 #define H_glDrawBuffer "void glDrawBuffer(GLenum mode)" 587 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glDrawBuffer", "GLenum"); 588 glDrawBuffer(Xen_to_C_GLenum(mode)); 589 return(Xen_false); 590 } 591 592 static Xen gxg_glReadBuffer(Xen mode) 593 { 594 #define H_glReadBuffer "void glReadBuffer(GLenum mode)" 595 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glReadBuffer", "GLenum"); 596 glReadBuffer(Xen_to_C_GLenum(mode)); 597 return(Xen_false); 598 } 599 600 static Xen gxg_glEnable(Xen cap) 601 { 602 #define H_glEnable "void glEnable(GLenum cap)" 603 Xen_check_type(Xen_is_GLenum(cap), cap, 1, "glEnable", "GLenum"); 604 glEnable(Xen_to_C_GLenum(cap)); 605 return(Xen_false); 606 } 607 608 static Xen gxg_glDisable(Xen cap) 609 { 610 #define H_glDisable "void glDisable(GLenum cap)" 611 Xen_check_type(Xen_is_GLenum(cap), cap, 1, "glDisable", "GLenum"); 612 glDisable(Xen_to_C_GLenum(cap)); 613 return(Xen_false); 614 } 615 616 static Xen gxg_glIsEnabled(Xen cap) 617 { 618 #define H_glIsEnabled "GLboolean glIsEnabled(GLenum cap)" 619 Xen_check_type(Xen_is_GLenum(cap), cap, 1, "glIsEnabled", "GLenum"); 620 return(C_to_Xen_GLboolean(glIsEnabled(Xen_to_C_GLenum(cap)))); 621 } 622 623 static Xen gxg_glEnableClientState(Xen cap) 624 { 625 #define H_glEnableClientState "void glEnableClientState(GLenum cap)" 626 Xen_check_type(Xen_is_GLenum(cap), cap, 1, "glEnableClientState", "GLenum"); 627 glEnableClientState(Xen_to_C_GLenum(cap)); 628 return(Xen_false); 629 } 630 631 static Xen gxg_glDisableClientState(Xen cap) 632 { 633 #define H_glDisableClientState "void glDisableClientState(GLenum cap)" 634 Xen_check_type(Xen_is_GLenum(cap), cap, 1, "glDisableClientState", "GLenum"); 635 glDisableClientState(Xen_to_C_GLenum(cap)); 636 return(Xen_false); 637 } 638 639 static Xen gxg_glGetBooleanv(Xen pname, Xen params) 640 { 641 #define H_glGetBooleanv "void glGetBooleanv(GLenum pname, GLboolean* [params])" 642 GLboolean ref_params[16]; 643 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glGetBooleanv", "GLenum"); 644 glGetBooleanv(Xen_to_C_GLenum(pname), ref_params); 645 { 646 Xen result; 647 int i, vals; 648 vals = how_many_vals(Xen_to_C_GLenum(pname)); 649 result = Xen_empty_list; 650 for (i = 0; i < vals; i++) 651 result = Xen_cons(C_to_Xen_GLboolean(ref_params[i]), result); 652 return(result); 653 } 654 } 655 656 static Xen gxg_glGetDoublev(Xen pname, Xen params) 657 { 658 #define H_glGetDoublev "void glGetDoublev(GLenum pname, GLdouble* [params])" 659 GLdouble ref_params[1]; 660 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glGetDoublev", "GLenum"); 661 glGetDoublev(Xen_to_C_GLenum(pname), ref_params); 662 return(Xen_list_1(C_to_Xen_GLdouble(ref_params[0]))); 663 } 664 665 static Xen gxg_glGetFloatv(Xen pname, Xen params) 666 { 667 #define H_glGetFloatv "void glGetFloatv(GLenum pname, GLfloat* [params])" 668 GLfloat ref_params[16]; 669 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glGetFloatv", "GLenum"); 670 glGetFloatv(Xen_to_C_GLenum(pname), ref_params); 671 { 672 Xen result; 673 int i, vals; 674 vals = how_many_vals(Xen_to_C_GLenum(pname)); 675 result = Xen_empty_list; 676 for (i = 0; i < vals; i++) 677 result = Xen_cons(C_to_Xen_GLfloat(ref_params[i]), result); 678 return(result); 679 } 680 } 681 682 static Xen gxg_glGetIntegerv(Xen pname, Xen params) 683 { 684 #define H_glGetIntegerv "void glGetIntegerv(GLenum pname, GLint* [params])" 685 GLint ref_params[16]; 686 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glGetIntegerv", "GLenum"); 687 glGetIntegerv(Xen_to_C_GLenum(pname), ref_params); 688 { 689 Xen result; 690 int i, vals; 691 vals = how_many_vals(Xen_to_C_GLenum(pname)); 692 result = Xen_empty_list; 693 for (i = 0; i < vals; i++) 694 result = Xen_cons(C_to_Xen_GLint(ref_params[i]), result); 695 return(result); 696 } 697 } 698 699 static Xen gxg_glPushAttrib(Xen mask) 700 { 701 #define H_glPushAttrib "void glPushAttrib(GLbitfield mask)" 702 Xen_check_type(Xen_is_GLbitfield(mask), mask, 1, "glPushAttrib", "GLbitfield"); 703 glPushAttrib(Xen_to_C_GLbitfield(mask)); 704 return(Xen_false); 705 } 706 707 static Xen gxg_glPopAttrib(void) 708 { 709 #define H_glPopAttrib "void glPopAttrib( void)" 710 glPopAttrib(); 711 return(Xen_false); 712 } 713 714 static Xen gxg_glPushClientAttrib(Xen mask) 715 { 716 #define H_glPushClientAttrib "void glPushClientAttrib(GLbitfield mask)" 717 Xen_check_type(Xen_is_GLbitfield(mask), mask, 1, "glPushClientAttrib", "GLbitfield"); 718 glPushClientAttrib(Xen_to_C_GLbitfield(mask)); 719 return(Xen_false); 720 } 721 722 static Xen gxg_glPopClientAttrib(void) 723 { 724 #define H_glPopClientAttrib "void glPopClientAttrib( void)" 725 glPopClientAttrib(); 726 return(Xen_false); 727 } 728 729 static Xen gxg_glRenderMode(Xen mode) 730 { 731 #define H_glRenderMode "GLint glRenderMode(GLenum mode)" 732 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glRenderMode", "GLenum"); 733 return(C_to_Xen_GLint(glRenderMode(Xen_to_C_GLenum(mode)))); 734 } 735 736 static Xen gxg_glGetError(void) 737 { 738 #define H_glGetError "GLenum glGetError( void)" 739 return(C_to_Xen_GLenum(glGetError())); 740 } 741 742 static Xen gxg_glGetString(Xen name) 743 { 744 #define H_glGetString "constchar* glGetString(GLenum name)" 745 Xen_check_type(Xen_is_GLenum(name), name, 1, "glGetString", "GLenum"); 746 return(C_to_Xen_constchar_(glGetString(Xen_to_C_GLenum(name)))); 747 } 748 749 static Xen gxg_glFinish(void) 750 { 751 #define H_glFinish "void glFinish( void)" 752 glFinish(); 753 return(Xen_false); 754 } 755 756 static Xen gxg_glFlush(void) 757 { 758 #define H_glFlush "void glFlush( void)" 759 glFlush(); 760 return(Xen_false); 761 } 762 763 static Xen gxg_glHint(Xen target, Xen mode) 764 { 765 #define H_glHint "void glHint(GLenum target, GLenum mode)" 766 Xen_check_type(Xen_is_GLenum(target), target, 1, "glHint", "GLenum"); 767 Xen_check_type(Xen_is_GLenum(mode), mode, 2, "glHint", "GLenum"); 768 glHint(Xen_to_C_GLenum(target), Xen_to_C_GLenum(mode)); 769 return(Xen_false); 770 } 771 772 static Xen gxg_glClearDepth(Xen depth) 773 { 774 #define H_glClearDepth "void glClearDepth(GLclampd depth)" 775 Xen_check_type(Xen_is_GLclampd(depth), depth, 1, "glClearDepth", "GLclampd"); 776 glClearDepth(Xen_to_C_GLclampd(depth)); 777 return(Xen_false); 778 } 779 780 static Xen gxg_glDepthFunc(Xen func) 781 { 782 #define H_glDepthFunc "void glDepthFunc(GLenum func)" 783 Xen_check_type(Xen_is_GLenum(func), func, 1, "glDepthFunc", "GLenum"); 784 glDepthFunc(Xen_to_C_GLenum(func)); 785 return(Xen_false); 786 } 787 788 static Xen gxg_glDepthMask(Xen flag) 789 { 790 #define H_glDepthMask "void glDepthMask(GLboolean flag)" 791 Xen_check_type(Xen_is_GLboolean(flag), flag, 1, "glDepthMask", "GLboolean"); 792 glDepthMask(Xen_to_C_GLboolean(flag)); 793 return(Xen_false); 794 } 795 796 static Xen gxg_glDepthRange(Xen near_val, Xen far_val) 797 { 798 #define H_glDepthRange "void glDepthRange(GLclampd near_val, GLclampd far_val)" 799 Xen_check_type(Xen_is_GLclampd(near_val), near_val, 1, "glDepthRange", "GLclampd"); 800 Xen_check_type(Xen_is_GLclampd(far_val), far_val, 2, "glDepthRange", "GLclampd"); 801 glDepthRange(Xen_to_C_GLclampd(near_val), Xen_to_C_GLclampd(far_val)); 802 return(Xen_false); 803 } 804 805 static Xen gxg_glClearAccum(Xen red, Xen green, Xen blue, Xen alpha) 806 { 807 #define H_glClearAccum "void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)" 808 Xen_check_type(Xen_is_GLfloat(red), red, 1, "glClearAccum", "GLfloat"); 809 Xen_check_type(Xen_is_GLfloat(green), green, 2, "glClearAccum", "GLfloat"); 810 Xen_check_type(Xen_is_GLfloat(blue), blue, 3, "glClearAccum", "GLfloat"); 811 Xen_check_type(Xen_is_GLfloat(alpha), alpha, 4, "glClearAccum", "GLfloat"); 812 glClearAccum(Xen_to_C_GLfloat(red), Xen_to_C_GLfloat(green), Xen_to_C_GLfloat(blue), Xen_to_C_GLfloat(alpha)); 813 return(Xen_false); 814 } 815 816 static Xen gxg_glAccum(Xen op, Xen value) 817 { 818 #define H_glAccum "void glAccum(GLenum op, GLfloat value)" 819 Xen_check_type(Xen_is_GLenum(op), op, 1, "glAccum", "GLenum"); 820 Xen_check_type(Xen_is_GLfloat(value), value, 2, "glAccum", "GLfloat"); 821 glAccum(Xen_to_C_GLenum(op), Xen_to_C_GLfloat(value)); 822 return(Xen_false); 823 } 824 825 static Xen gxg_glMatrixMode(Xen mode) 826 { 827 #define H_glMatrixMode "void glMatrixMode(GLenum mode)" 828 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glMatrixMode", "GLenum"); 829 glMatrixMode(Xen_to_C_GLenum(mode)); 830 return(Xen_false); 831 } 832 833 static Xen gxg_glOrtho(Xen left, Xen right, Xen bottom, Xen top, Xen near_val, Xen far_val) 834 { 835 #define H_glOrtho "void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, \ 836 GLdouble far_val)" 837 Xen_check_type(Xen_is_GLdouble(left), left, 1, "glOrtho", "GLdouble"); 838 Xen_check_type(Xen_is_GLdouble(right), right, 2, "glOrtho", "GLdouble"); 839 Xen_check_type(Xen_is_GLdouble(bottom), bottom, 3, "glOrtho", "GLdouble"); 840 Xen_check_type(Xen_is_GLdouble(top), top, 4, "glOrtho", "GLdouble"); 841 Xen_check_type(Xen_is_GLdouble(near_val), near_val, 5, "glOrtho", "GLdouble"); 842 Xen_check_type(Xen_is_GLdouble(far_val), far_val, 6, "glOrtho", "GLdouble"); 843 glOrtho(Xen_to_C_GLdouble(left), Xen_to_C_GLdouble(right), Xen_to_C_GLdouble(bottom), Xen_to_C_GLdouble(top), Xen_to_C_GLdouble(near_val), 844 Xen_to_C_GLdouble(far_val)); 845 return(Xen_false); 846 } 847 848 static Xen gxg_glFrustum(Xen left, Xen right, Xen bottom, Xen top, Xen near_val, Xen far_val) 849 { 850 #define H_glFrustum "void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, \ 851 GLdouble far_val)" 852 Xen_check_type(Xen_is_GLdouble(left), left, 1, "glFrustum", "GLdouble"); 853 Xen_check_type(Xen_is_GLdouble(right), right, 2, "glFrustum", "GLdouble"); 854 Xen_check_type(Xen_is_GLdouble(bottom), bottom, 3, "glFrustum", "GLdouble"); 855 Xen_check_type(Xen_is_GLdouble(top), top, 4, "glFrustum", "GLdouble"); 856 Xen_check_type(Xen_is_GLdouble(near_val), near_val, 5, "glFrustum", "GLdouble"); 857 Xen_check_type(Xen_is_GLdouble(far_val), far_val, 6, "glFrustum", "GLdouble"); 858 glFrustum(Xen_to_C_GLdouble(left), Xen_to_C_GLdouble(right), Xen_to_C_GLdouble(bottom), Xen_to_C_GLdouble(top), Xen_to_C_GLdouble(near_val), 859 Xen_to_C_GLdouble(far_val)); 860 return(Xen_false); 861 } 862 863 static Xen gxg_glViewport(Xen x, Xen y, Xen width, Xen height) 864 { 865 #define H_glViewport "void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)" 866 Xen_check_type(Xen_is_GLint(x), x, 1, "glViewport", "GLint"); 867 Xen_check_type(Xen_is_GLint(y), y, 2, "glViewport", "GLint"); 868 Xen_check_type(Xen_is_GLsizei(width), width, 3, "glViewport", "GLsizei"); 869 Xen_check_type(Xen_is_GLsizei(height), height, 4, "glViewport", "GLsizei"); 870 glViewport(Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height)); 871 return(Xen_false); 872 } 873 874 static Xen gxg_glPushMatrix(void) 875 { 876 #define H_glPushMatrix "void glPushMatrix( void)" 877 glPushMatrix(); 878 return(Xen_false); 879 } 880 881 static Xen gxg_glPopMatrix(void) 882 { 883 #define H_glPopMatrix "void glPopMatrix( void)" 884 glPopMatrix(); 885 return(Xen_false); 886 } 887 888 static Xen gxg_glLoadIdentity(void) 889 { 890 #define H_glLoadIdentity "void glLoadIdentity( void)" 891 glLoadIdentity(); 892 return(Xen_false); 893 } 894 895 static Xen gxg_glLoadMatrixd(Xen m) 896 { 897 #define H_glLoadMatrixd "void glLoadMatrixd(GLdouble* m)" 898 Xen_check_type(Xen_is_GLdouble_(m), m, 1, "glLoadMatrixd", "GLdouble*"); 899 glLoadMatrixd(Xen_to_C_GLdouble_(m)); 900 return(Xen_false); 901 } 902 903 static Xen gxg_glLoadMatrixf(Xen m) 904 { 905 #define H_glLoadMatrixf "void glLoadMatrixf(GLfloat* m)" 906 Xen_check_type(Xen_is_GLfloat_(m), m, 1, "glLoadMatrixf", "GLfloat*"); 907 glLoadMatrixf(Xen_to_C_GLfloat_(m)); 908 return(Xen_false); 909 } 910 911 static Xen gxg_glMultMatrixd(Xen m) 912 { 913 #define H_glMultMatrixd "void glMultMatrixd(GLdouble* m)" 914 Xen_check_type(Xen_is_GLdouble_(m), m, 1, "glMultMatrixd", "GLdouble*"); 915 glMultMatrixd(Xen_to_C_GLdouble_(m)); 916 return(Xen_false); 917 } 918 919 static Xen gxg_glMultMatrixf(Xen m) 920 { 921 #define H_glMultMatrixf "void glMultMatrixf(GLfloat* m)" 922 Xen_check_type(Xen_is_GLfloat_(m), m, 1, "glMultMatrixf", "GLfloat*"); 923 glMultMatrixf(Xen_to_C_GLfloat_(m)); 924 return(Xen_false); 925 } 926 927 static Xen gxg_glRotated(Xen angle, Xen x, Xen y, Xen z) 928 { 929 #define H_glRotated "void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)" 930 Xen_check_type(Xen_is_GLdouble(angle), angle, 1, "glRotated", "GLdouble"); 931 Xen_check_type(Xen_is_GLdouble(x), x, 2, "glRotated", "GLdouble"); 932 Xen_check_type(Xen_is_GLdouble(y), y, 3, "glRotated", "GLdouble"); 933 Xen_check_type(Xen_is_GLdouble(z), z, 4, "glRotated", "GLdouble"); 934 glRotated(Xen_to_C_GLdouble(angle), Xen_to_C_GLdouble(x), Xen_to_C_GLdouble(y), Xen_to_C_GLdouble(z)); 935 return(Xen_false); 936 } 937 938 static Xen gxg_glRotatef(Xen angle, Xen x, Xen y, Xen z) 939 { 940 #define H_glRotatef "void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)" 941 Xen_check_type(Xen_is_GLfloat(angle), angle, 1, "glRotatef", "GLfloat"); 942 Xen_check_type(Xen_is_GLfloat(x), x, 2, "glRotatef", "GLfloat"); 943 Xen_check_type(Xen_is_GLfloat(y), y, 3, "glRotatef", "GLfloat"); 944 Xen_check_type(Xen_is_GLfloat(z), z, 4, "glRotatef", "GLfloat"); 945 glRotatef(Xen_to_C_GLfloat(angle), Xen_to_C_GLfloat(x), Xen_to_C_GLfloat(y), Xen_to_C_GLfloat(z)); 946 return(Xen_false); 947 } 948 949 static Xen gxg_glScaled(Xen x, Xen y, Xen z) 950 { 951 #define H_glScaled "void glScaled(GLdouble x, GLdouble y, GLdouble z)" 952 Xen_check_type(Xen_is_GLdouble(x), x, 1, "glScaled", "GLdouble"); 953 Xen_check_type(Xen_is_GLdouble(y), y, 2, "glScaled", "GLdouble"); 954 Xen_check_type(Xen_is_GLdouble(z), z, 3, "glScaled", "GLdouble"); 955 glScaled(Xen_to_C_GLdouble(x), Xen_to_C_GLdouble(y), Xen_to_C_GLdouble(z)); 956 return(Xen_false); 957 } 958 959 static Xen gxg_glScalef(Xen x, Xen y, Xen z) 960 { 961 #define H_glScalef "void glScalef(GLfloat x, GLfloat y, GLfloat z)" 962 Xen_check_type(Xen_is_GLfloat(x), x, 1, "glScalef", "GLfloat"); 963 Xen_check_type(Xen_is_GLfloat(y), y, 2, "glScalef", "GLfloat"); 964 Xen_check_type(Xen_is_GLfloat(z), z, 3, "glScalef", "GLfloat"); 965 glScalef(Xen_to_C_GLfloat(x), Xen_to_C_GLfloat(y), Xen_to_C_GLfloat(z)); 966 return(Xen_false); 967 } 968 969 static Xen gxg_glTranslated(Xen x, Xen y, Xen z) 970 { 971 #define H_glTranslated "void glTranslated(GLdouble x, GLdouble y, GLdouble z)" 972 Xen_check_type(Xen_is_GLdouble(x), x, 1, "glTranslated", "GLdouble"); 973 Xen_check_type(Xen_is_GLdouble(y), y, 2, "glTranslated", "GLdouble"); 974 Xen_check_type(Xen_is_GLdouble(z), z, 3, "glTranslated", "GLdouble"); 975 glTranslated(Xen_to_C_GLdouble(x), Xen_to_C_GLdouble(y), Xen_to_C_GLdouble(z)); 976 return(Xen_false); 977 } 978 979 static Xen gxg_glTranslatef(Xen x, Xen y, Xen z) 980 { 981 #define H_glTranslatef "void glTranslatef(GLfloat x, GLfloat y, GLfloat z)" 982 Xen_check_type(Xen_is_GLfloat(x), x, 1, "glTranslatef", "GLfloat"); 983 Xen_check_type(Xen_is_GLfloat(y), y, 2, "glTranslatef", "GLfloat"); 984 Xen_check_type(Xen_is_GLfloat(z), z, 3, "glTranslatef", "GLfloat"); 985 glTranslatef(Xen_to_C_GLfloat(x), Xen_to_C_GLfloat(y), Xen_to_C_GLfloat(z)); 986 return(Xen_false); 987 } 988 989 static Xen gxg_glIsList(Xen list) 990 { 991 #define H_glIsList "GLboolean glIsList(GLuint list)" 992 Xen_check_type(Xen_is_GLuint(list), list, 1, "glIsList", "GLuint"); 993 return(C_to_Xen_GLboolean(glIsList(Xen_to_C_GLuint(list)))); 994 } 995 996 static Xen gxg_glDeleteLists(Xen list, Xen range) 997 { 998 #define H_glDeleteLists "void glDeleteLists(GLuint list, GLsizei range)" 999 Xen_check_type(Xen_is_GLuint(list), list, 1, "glDeleteLists", "GLuint"); 1000 Xen_check_type(Xen_is_GLsizei(range), range, 2, "glDeleteLists", "GLsizei"); 1001 glDeleteLists(Xen_to_C_GLuint(list), Xen_to_C_GLsizei(range)); 1002 return(Xen_false); 1003 } 1004 1005 static Xen gxg_glGenLists(Xen range) 1006 { 1007 #define H_glGenLists "GLuint glGenLists(GLsizei range)" 1008 Xen_check_type(Xen_is_GLsizei(range), range, 1, "glGenLists", "GLsizei"); 1009 return(C_to_Xen_GLuint(glGenLists(Xen_to_C_GLsizei(range)))); 1010 } 1011 1012 static Xen gxg_glNewList(Xen list, Xen mode) 1013 { 1014 #define H_glNewList "void glNewList(GLuint list, GLenum mode)" 1015 Xen_check_type(Xen_is_GLuint(list), list, 1, "glNewList", "GLuint"); 1016 Xen_check_type(Xen_is_GLenum(mode), mode, 2, "glNewList", "GLenum"); 1017 glNewList(Xen_to_C_GLuint(list), Xen_to_C_GLenum(mode)); 1018 return(Xen_false); 1019 } 1020 1021 static Xen gxg_glEndList(void) 1022 { 1023 #define H_glEndList "void glEndList( void)" 1024 glEndList(); 1025 return(Xen_false); 1026 } 1027 1028 static Xen gxg_glCallList(Xen list) 1029 { 1030 #define H_glCallList "void glCallList(GLuint list)" 1031 Xen_check_type(Xen_is_GLuint(list), list, 1, "glCallList", "GLuint"); 1032 glCallList(Xen_to_C_GLuint(list)); 1033 return(Xen_false); 1034 } 1035 1036 static Xen gxg_glCallLists(Xen n, Xen type, Xen lists) 1037 { 1038 #define H_glCallLists "void glCallLists(GLsizei n, GLenum type, GLvoid* lists)" 1039 Xen_check_type(Xen_is_GLsizei(n), n, 1, "glCallLists", "GLsizei"); 1040 Xen_check_type(Xen_is_GLenum(type), type, 2, "glCallLists", "GLenum"); 1041 Xen_check_type(Xen_is_GLvoid_(lists), lists, 3, "glCallLists", "GLvoid*"); 1042 glCallLists(Xen_to_C_GLsizei(n), Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(lists)); 1043 return(Xen_false); 1044 } 1045 1046 static Xen gxg_glListBase(Xen base) 1047 { 1048 #define H_glListBase "void glListBase(GLuint base)" 1049 Xen_check_type(Xen_is_GLuint(base), base, 1, "glListBase", "GLuint"); 1050 glListBase(Xen_to_C_GLuint(base)); 1051 return(Xen_false); 1052 } 1053 1054 static Xen gxg_glBegin(Xen mode) 1055 { 1056 #define H_glBegin "void glBegin(GLenum mode)" 1057 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glBegin", "GLenum"); 1058 glBegin(Xen_to_C_GLenum(mode)); 1059 return(Xen_false); 1060 } 1061 1062 static Xen gxg_glEnd(void) 1063 { 1064 #define H_glEnd "void glEnd( void)" 1065 glEnd(); 1066 return(Xen_false); 1067 } 1068 1069 static Xen gxg_glVertex2d(Xen x, Xen y) 1070 { 1071 #define H_glVertex2d "void glVertex2d(GLdouble x, GLdouble y)" 1072 Xen_check_type(Xen_is_GLdouble(x), x, 1, "glVertex2d", "GLdouble"); 1073 Xen_check_type(Xen_is_GLdouble(y), y, 2, "glVertex2d", "GLdouble"); 1074 glVertex2d(Xen_to_C_GLdouble(x), Xen_to_C_GLdouble(y)); 1075 return(Xen_false); 1076 } 1077 1078 static Xen gxg_glVertex2f(Xen x, Xen y) 1079 { 1080 #define H_glVertex2f "void glVertex2f(GLfloat x, GLfloat y)" 1081 Xen_check_type(Xen_is_GLfloat(x), x, 1, "glVertex2f", "GLfloat"); 1082 Xen_check_type(Xen_is_GLfloat(y), y, 2, "glVertex2f", "GLfloat"); 1083 glVertex2f(Xen_to_C_GLfloat(x), Xen_to_C_GLfloat(y)); 1084 return(Xen_false); 1085 } 1086 1087 static Xen gxg_glVertex2i(Xen x, Xen y) 1088 { 1089 #define H_glVertex2i "void glVertex2i(GLint x, GLint y)" 1090 Xen_check_type(Xen_is_GLint(x), x, 1, "glVertex2i", "GLint"); 1091 Xen_check_type(Xen_is_GLint(y), y, 2, "glVertex2i", "GLint"); 1092 glVertex2i(Xen_to_C_GLint(x), Xen_to_C_GLint(y)); 1093 return(Xen_false); 1094 } 1095 1096 static Xen gxg_glVertex2s(Xen x, Xen y) 1097 { 1098 #define H_glVertex2s "void glVertex2s(GLshort x, GLshort y)" 1099 Xen_check_type(Xen_is_GLshort(x), x, 1, "glVertex2s", "GLshort"); 1100 Xen_check_type(Xen_is_GLshort(y), y, 2, "glVertex2s", "GLshort"); 1101 glVertex2s(Xen_to_C_GLshort(x), Xen_to_C_GLshort(y)); 1102 return(Xen_false); 1103 } 1104 1105 static Xen gxg_glVertex3d(Xen x, Xen y, Xen z) 1106 { 1107 #define H_glVertex3d "void glVertex3d(GLdouble x, GLdouble y, GLdouble z)" 1108 Xen_check_type(Xen_is_GLdouble(x), x, 1, "glVertex3d", "GLdouble"); 1109 Xen_check_type(Xen_is_GLdouble(y), y, 2, "glVertex3d", "GLdouble"); 1110 Xen_check_type(Xen_is_GLdouble(z), z, 3, "glVertex3d", "GLdouble"); 1111 glVertex3d(Xen_to_C_GLdouble(x), Xen_to_C_GLdouble(y), Xen_to_C_GLdouble(z)); 1112 return(Xen_false); 1113 } 1114 1115 static Xen gxg_glVertex3f(Xen x, Xen y, Xen z) 1116 { 1117 #define H_glVertex3f "void glVertex3f(GLfloat x, GLfloat y, GLfloat z)" 1118 Xen_check_type(Xen_is_GLfloat(x), x, 1, "glVertex3f", "GLfloat"); 1119 Xen_check_type(Xen_is_GLfloat(y), y, 2, "glVertex3f", "GLfloat"); 1120 Xen_check_type(Xen_is_GLfloat(z), z, 3, "glVertex3f", "GLfloat"); 1121 glVertex3f(Xen_to_C_GLfloat(x), Xen_to_C_GLfloat(y), Xen_to_C_GLfloat(z)); 1122 return(Xen_false); 1123 } 1124 1125 static Xen gxg_glVertex3i(Xen x, Xen y, Xen z) 1126 { 1127 #define H_glVertex3i "void glVertex3i(GLint x, GLint y, GLint z)" 1128 Xen_check_type(Xen_is_GLint(x), x, 1, "glVertex3i", "GLint"); 1129 Xen_check_type(Xen_is_GLint(y), y, 2, "glVertex3i", "GLint"); 1130 Xen_check_type(Xen_is_GLint(z), z, 3, "glVertex3i", "GLint"); 1131 glVertex3i(Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLint(z)); 1132 return(Xen_false); 1133 } 1134 1135 static Xen gxg_glVertex3s(Xen x, Xen y, Xen z) 1136 { 1137 #define H_glVertex3s "void glVertex3s(GLshort x, GLshort y, GLshort z)" 1138 Xen_check_type(Xen_is_GLshort(x), x, 1, "glVertex3s", "GLshort"); 1139 Xen_check_type(Xen_is_GLshort(y), y, 2, "glVertex3s", "GLshort"); 1140 Xen_check_type(Xen_is_GLshort(z), z, 3, "glVertex3s", "GLshort"); 1141 glVertex3s(Xen_to_C_GLshort(x), Xen_to_C_GLshort(y), Xen_to_C_GLshort(z)); 1142 return(Xen_false); 1143 } 1144 1145 static Xen gxg_glVertex4d(Xen x, Xen y, Xen z, Xen w) 1146 { 1147 #define H_glVertex4d "void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)" 1148 Xen_check_type(Xen_is_GLdouble(x), x, 1, "glVertex4d", "GLdouble"); 1149 Xen_check_type(Xen_is_GLdouble(y), y, 2, "glVertex4d", "GLdouble"); 1150 Xen_check_type(Xen_is_GLdouble(z), z, 3, "glVertex4d", "GLdouble"); 1151 Xen_check_type(Xen_is_GLdouble(w), w, 4, "glVertex4d", "GLdouble"); 1152 glVertex4d(Xen_to_C_GLdouble(x), Xen_to_C_GLdouble(y), Xen_to_C_GLdouble(z), Xen_to_C_GLdouble(w)); 1153 return(Xen_false); 1154 } 1155 1156 static Xen gxg_glVertex4f(Xen x, Xen y, Xen z, Xen w) 1157 { 1158 #define H_glVertex4f "void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)" 1159 Xen_check_type(Xen_is_GLfloat(x), x, 1, "glVertex4f", "GLfloat"); 1160 Xen_check_type(Xen_is_GLfloat(y), y, 2, "glVertex4f", "GLfloat"); 1161 Xen_check_type(Xen_is_GLfloat(z), z, 3, "glVertex4f", "GLfloat"); 1162 Xen_check_type(Xen_is_GLfloat(w), w, 4, "glVertex4f", "GLfloat"); 1163 glVertex4f(Xen_to_C_GLfloat(x), Xen_to_C_GLfloat(y), Xen_to_C_GLfloat(z), Xen_to_C_GLfloat(w)); 1164 return(Xen_false); 1165 } 1166 1167 static Xen gxg_glVertex4i(Xen x, Xen y, Xen z, Xen w) 1168 { 1169 #define H_glVertex4i "void glVertex4i(GLint x, GLint y, GLint z, GLint w)" 1170 Xen_check_type(Xen_is_GLint(x), x, 1, "glVertex4i", "GLint"); 1171 Xen_check_type(Xen_is_GLint(y), y, 2, "glVertex4i", "GLint"); 1172 Xen_check_type(Xen_is_GLint(z), z, 3, "glVertex4i", "GLint"); 1173 Xen_check_type(Xen_is_GLint(w), w, 4, "glVertex4i", "GLint"); 1174 glVertex4i(Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLint(z), Xen_to_C_GLint(w)); 1175 return(Xen_false); 1176 } 1177 1178 static Xen gxg_glVertex4s(Xen x, Xen y, Xen z, Xen w) 1179 { 1180 #define H_glVertex4s "void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)" 1181 Xen_check_type(Xen_is_GLshort(x), x, 1, "glVertex4s", "GLshort"); 1182 Xen_check_type(Xen_is_GLshort(y), y, 2, "glVertex4s", "GLshort"); 1183 Xen_check_type(Xen_is_GLshort(z), z, 3, "glVertex4s", "GLshort"); 1184 Xen_check_type(Xen_is_GLshort(w), w, 4, "glVertex4s", "GLshort"); 1185 glVertex4s(Xen_to_C_GLshort(x), Xen_to_C_GLshort(y), Xen_to_C_GLshort(z), Xen_to_C_GLshort(w)); 1186 return(Xen_false); 1187 } 1188 1189 static Xen gxg_glNormal3b(Xen nx, Xen ny, Xen nz) 1190 { 1191 #define H_glNormal3b "void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)" 1192 Xen_check_type(Xen_is_GLbyte(nx), nx, 1, "glNormal3b", "GLbyte"); 1193 Xen_check_type(Xen_is_GLbyte(ny), ny, 2, "glNormal3b", "GLbyte"); 1194 Xen_check_type(Xen_is_GLbyte(nz), nz, 3, "glNormal3b", "GLbyte"); 1195 glNormal3b(Xen_to_C_GLbyte(nx), Xen_to_C_GLbyte(ny), Xen_to_C_GLbyte(nz)); 1196 return(Xen_false); 1197 } 1198 1199 static Xen gxg_glNormal3d(Xen nx, Xen ny, Xen nz) 1200 { 1201 #define H_glNormal3d "void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)" 1202 Xen_check_type(Xen_is_GLdouble(nx), nx, 1, "glNormal3d", "GLdouble"); 1203 Xen_check_type(Xen_is_GLdouble(ny), ny, 2, "glNormal3d", "GLdouble"); 1204 Xen_check_type(Xen_is_GLdouble(nz), nz, 3, "glNormal3d", "GLdouble"); 1205 glNormal3d(Xen_to_C_GLdouble(nx), Xen_to_C_GLdouble(ny), Xen_to_C_GLdouble(nz)); 1206 return(Xen_false); 1207 } 1208 1209 static Xen gxg_glNormal3f(Xen nx, Xen ny, Xen nz) 1210 { 1211 #define H_glNormal3f "void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)" 1212 Xen_check_type(Xen_is_GLfloat(nx), nx, 1, "glNormal3f", "GLfloat"); 1213 Xen_check_type(Xen_is_GLfloat(ny), ny, 2, "glNormal3f", "GLfloat"); 1214 Xen_check_type(Xen_is_GLfloat(nz), nz, 3, "glNormal3f", "GLfloat"); 1215 glNormal3f(Xen_to_C_GLfloat(nx), Xen_to_C_GLfloat(ny), Xen_to_C_GLfloat(nz)); 1216 return(Xen_false); 1217 } 1218 1219 static Xen gxg_glNormal3i(Xen nx, Xen ny, Xen nz) 1220 { 1221 #define H_glNormal3i "void glNormal3i(GLint nx, GLint ny, GLint nz)" 1222 Xen_check_type(Xen_is_GLint(nx), nx, 1, "glNormal3i", "GLint"); 1223 Xen_check_type(Xen_is_GLint(ny), ny, 2, "glNormal3i", "GLint"); 1224 Xen_check_type(Xen_is_GLint(nz), nz, 3, "glNormal3i", "GLint"); 1225 glNormal3i(Xen_to_C_GLint(nx), Xen_to_C_GLint(ny), Xen_to_C_GLint(nz)); 1226 return(Xen_false); 1227 } 1228 1229 static Xen gxg_glNormal3s(Xen nx, Xen ny, Xen nz) 1230 { 1231 #define H_glNormal3s "void glNormal3s(GLshort nx, GLshort ny, GLshort nz)" 1232 Xen_check_type(Xen_is_GLshort(nx), nx, 1, "glNormal3s", "GLshort"); 1233 Xen_check_type(Xen_is_GLshort(ny), ny, 2, "glNormal3s", "GLshort"); 1234 Xen_check_type(Xen_is_GLshort(nz), nz, 3, "glNormal3s", "GLshort"); 1235 glNormal3s(Xen_to_C_GLshort(nx), Xen_to_C_GLshort(ny), Xen_to_C_GLshort(nz)); 1236 return(Xen_false); 1237 } 1238 1239 static Xen gxg_glIndexd(Xen c) 1240 { 1241 #define H_glIndexd "void glIndexd(GLdouble c)" 1242 Xen_check_type(Xen_is_GLdouble(c), c, 1, "glIndexd", "GLdouble"); 1243 glIndexd(Xen_to_C_GLdouble(c)); 1244 return(Xen_false); 1245 } 1246 1247 static Xen gxg_glIndexf(Xen c) 1248 { 1249 #define H_glIndexf "void glIndexf(GLfloat c)" 1250 Xen_check_type(Xen_is_GLfloat(c), c, 1, "glIndexf", "GLfloat"); 1251 glIndexf(Xen_to_C_GLfloat(c)); 1252 return(Xen_false); 1253 } 1254 1255 static Xen gxg_glIndexi(Xen c) 1256 { 1257 #define H_glIndexi "void glIndexi(GLint c)" 1258 Xen_check_type(Xen_is_GLint(c), c, 1, "glIndexi", "GLint"); 1259 glIndexi(Xen_to_C_GLint(c)); 1260 return(Xen_false); 1261 } 1262 1263 static Xen gxg_glIndexs(Xen c) 1264 { 1265 #define H_glIndexs "void glIndexs(GLshort c)" 1266 Xen_check_type(Xen_is_GLshort(c), c, 1, "glIndexs", "GLshort"); 1267 glIndexs(Xen_to_C_GLshort(c)); 1268 return(Xen_false); 1269 } 1270 1271 static Xen gxg_glIndexub(Xen c) 1272 { 1273 #define H_glIndexub "void glIndexub(GLubyte c)" 1274 Xen_check_type(Xen_is_GLubyte(c), c, 1, "glIndexub", "GLubyte"); 1275 glIndexub(Xen_to_C_GLubyte(c)); 1276 return(Xen_false); 1277 } 1278 1279 static Xen gxg_glColor3b(Xen red, Xen green, Xen blue) 1280 { 1281 #define H_glColor3b "void glColor3b(GLbyte red, GLbyte green, GLbyte blue)" 1282 Xen_check_type(Xen_is_GLbyte(red), red, 1, "glColor3b", "GLbyte"); 1283 Xen_check_type(Xen_is_GLbyte(green), green, 2, "glColor3b", "GLbyte"); 1284 Xen_check_type(Xen_is_GLbyte(blue), blue, 3, "glColor3b", "GLbyte"); 1285 glColor3b(Xen_to_C_GLbyte(red), Xen_to_C_GLbyte(green), Xen_to_C_GLbyte(blue)); 1286 return(Xen_false); 1287 } 1288 1289 static Xen gxg_glColor3d(Xen red, Xen green, Xen blue) 1290 { 1291 #define H_glColor3d "void glColor3d(GLdouble red, GLdouble green, GLdouble blue)" 1292 Xen_check_type(Xen_is_GLdouble(red), red, 1, "glColor3d", "GLdouble"); 1293 Xen_check_type(Xen_is_GLdouble(green), green, 2, "glColor3d", "GLdouble"); 1294 Xen_check_type(Xen_is_GLdouble(blue), blue, 3, "glColor3d", "GLdouble"); 1295 glColor3d(Xen_to_C_GLdouble(red), Xen_to_C_GLdouble(green), Xen_to_C_GLdouble(blue)); 1296 return(Xen_false); 1297 } 1298 1299 static Xen gxg_glColor3f(Xen red, Xen green, Xen blue) 1300 { 1301 #define H_glColor3f "void glColor3f(GLfloat red, GLfloat green, GLfloat blue)" 1302 Xen_check_type(Xen_is_GLfloat(red), red, 1, "glColor3f", "GLfloat"); 1303 Xen_check_type(Xen_is_GLfloat(green), green, 2, "glColor3f", "GLfloat"); 1304 Xen_check_type(Xen_is_GLfloat(blue), blue, 3, "glColor3f", "GLfloat"); 1305 glColor3f(Xen_to_C_GLfloat(red), Xen_to_C_GLfloat(green), Xen_to_C_GLfloat(blue)); 1306 return(Xen_false); 1307 } 1308 1309 static Xen gxg_glColor3i(Xen red, Xen green, Xen blue) 1310 { 1311 #define H_glColor3i "void glColor3i(GLint red, GLint green, GLint blue)" 1312 Xen_check_type(Xen_is_GLint(red), red, 1, "glColor3i", "GLint"); 1313 Xen_check_type(Xen_is_GLint(green), green, 2, "glColor3i", "GLint"); 1314 Xen_check_type(Xen_is_GLint(blue), blue, 3, "glColor3i", "GLint"); 1315 glColor3i(Xen_to_C_GLint(red), Xen_to_C_GLint(green), Xen_to_C_GLint(blue)); 1316 return(Xen_false); 1317 } 1318 1319 static Xen gxg_glColor3s(Xen red, Xen green, Xen blue) 1320 { 1321 #define H_glColor3s "void glColor3s(GLshort red, GLshort green, GLshort blue)" 1322 Xen_check_type(Xen_is_GLshort(red), red, 1, "glColor3s", "GLshort"); 1323 Xen_check_type(Xen_is_GLshort(green), green, 2, "glColor3s", "GLshort"); 1324 Xen_check_type(Xen_is_GLshort(blue), blue, 3, "glColor3s", "GLshort"); 1325 glColor3s(Xen_to_C_GLshort(red), Xen_to_C_GLshort(green), Xen_to_C_GLshort(blue)); 1326 return(Xen_false); 1327 } 1328 1329 static Xen gxg_glColor3ub(Xen red, Xen green, Xen blue) 1330 { 1331 #define H_glColor3ub "void glColor3ub(GLubyte red, GLubyte green, GLubyte blue)" 1332 Xen_check_type(Xen_is_GLubyte(red), red, 1, "glColor3ub", "GLubyte"); 1333 Xen_check_type(Xen_is_GLubyte(green), green, 2, "glColor3ub", "GLubyte"); 1334 Xen_check_type(Xen_is_GLubyte(blue), blue, 3, "glColor3ub", "GLubyte"); 1335 glColor3ub(Xen_to_C_GLubyte(red), Xen_to_C_GLubyte(green), Xen_to_C_GLubyte(blue)); 1336 return(Xen_false); 1337 } 1338 1339 static Xen gxg_glColor3ui(Xen red, Xen green, Xen blue) 1340 { 1341 #define H_glColor3ui "void glColor3ui(GLuint red, GLuint green, GLuint blue)" 1342 Xen_check_type(Xen_is_GLuint(red), red, 1, "glColor3ui", "GLuint"); 1343 Xen_check_type(Xen_is_GLuint(green), green, 2, "glColor3ui", "GLuint"); 1344 Xen_check_type(Xen_is_GLuint(blue), blue, 3, "glColor3ui", "GLuint"); 1345 glColor3ui(Xen_to_C_GLuint(red), Xen_to_C_GLuint(green), Xen_to_C_GLuint(blue)); 1346 return(Xen_false); 1347 } 1348 1349 static Xen gxg_glColor3us(Xen red, Xen green, Xen blue) 1350 { 1351 #define H_glColor3us "void glColor3us(GLushort red, GLushort green, GLushort blue)" 1352 Xen_check_type(Xen_is_GLushort(red), red, 1, "glColor3us", "GLushort"); 1353 Xen_check_type(Xen_is_GLushort(green), green, 2, "glColor3us", "GLushort"); 1354 Xen_check_type(Xen_is_GLushort(blue), blue, 3, "glColor3us", "GLushort"); 1355 glColor3us(Xen_to_C_GLushort(red), Xen_to_C_GLushort(green), Xen_to_C_GLushort(blue)); 1356 return(Xen_false); 1357 } 1358 1359 static Xen gxg_glColor4b(Xen red, Xen green, Xen blue, Xen alpha) 1360 { 1361 #define H_glColor4b "void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)" 1362 Xen_check_type(Xen_is_GLbyte(red), red, 1, "glColor4b", "GLbyte"); 1363 Xen_check_type(Xen_is_GLbyte(green), green, 2, "glColor4b", "GLbyte"); 1364 Xen_check_type(Xen_is_GLbyte(blue), blue, 3, "glColor4b", "GLbyte"); 1365 Xen_check_type(Xen_is_GLbyte(alpha), alpha, 4, "glColor4b", "GLbyte"); 1366 glColor4b(Xen_to_C_GLbyte(red), Xen_to_C_GLbyte(green), Xen_to_C_GLbyte(blue), Xen_to_C_GLbyte(alpha)); 1367 return(Xen_false); 1368 } 1369 1370 static Xen gxg_glColor4d(Xen red, Xen green, Xen blue, Xen alpha) 1371 { 1372 #define H_glColor4d "void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)" 1373 Xen_check_type(Xen_is_GLdouble(red), red, 1, "glColor4d", "GLdouble"); 1374 Xen_check_type(Xen_is_GLdouble(green), green, 2, "glColor4d", "GLdouble"); 1375 Xen_check_type(Xen_is_GLdouble(blue), blue, 3, "glColor4d", "GLdouble"); 1376 Xen_check_type(Xen_is_GLdouble(alpha), alpha, 4, "glColor4d", "GLdouble"); 1377 glColor4d(Xen_to_C_GLdouble(red), Xen_to_C_GLdouble(green), Xen_to_C_GLdouble(blue), Xen_to_C_GLdouble(alpha)); 1378 return(Xen_false); 1379 } 1380 1381 static Xen gxg_glColor4f(Xen red, Xen green, Xen blue, Xen alpha) 1382 { 1383 #define H_glColor4f "void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)" 1384 Xen_check_type(Xen_is_GLfloat(red), red, 1, "glColor4f", "GLfloat"); 1385 Xen_check_type(Xen_is_GLfloat(green), green, 2, "glColor4f", "GLfloat"); 1386 Xen_check_type(Xen_is_GLfloat(blue), blue, 3, "glColor4f", "GLfloat"); 1387 Xen_check_type(Xen_is_GLfloat(alpha), alpha, 4, "glColor4f", "GLfloat"); 1388 glColor4f(Xen_to_C_GLfloat(red), Xen_to_C_GLfloat(green), Xen_to_C_GLfloat(blue), Xen_to_C_GLfloat(alpha)); 1389 return(Xen_false); 1390 } 1391 1392 static Xen gxg_glColor4i(Xen red, Xen green, Xen blue, Xen alpha) 1393 { 1394 #define H_glColor4i "void glColor4i(GLint red, GLint green, GLint blue, GLint alpha)" 1395 Xen_check_type(Xen_is_GLint(red), red, 1, "glColor4i", "GLint"); 1396 Xen_check_type(Xen_is_GLint(green), green, 2, "glColor4i", "GLint"); 1397 Xen_check_type(Xen_is_GLint(blue), blue, 3, "glColor4i", "GLint"); 1398 Xen_check_type(Xen_is_GLint(alpha), alpha, 4, "glColor4i", "GLint"); 1399 glColor4i(Xen_to_C_GLint(red), Xen_to_C_GLint(green), Xen_to_C_GLint(blue), Xen_to_C_GLint(alpha)); 1400 return(Xen_false); 1401 } 1402 1403 static Xen gxg_glColor4s(Xen red, Xen green, Xen blue, Xen alpha) 1404 { 1405 #define H_glColor4s "void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)" 1406 Xen_check_type(Xen_is_GLshort(red), red, 1, "glColor4s", "GLshort"); 1407 Xen_check_type(Xen_is_GLshort(green), green, 2, "glColor4s", "GLshort"); 1408 Xen_check_type(Xen_is_GLshort(blue), blue, 3, "glColor4s", "GLshort"); 1409 Xen_check_type(Xen_is_GLshort(alpha), alpha, 4, "glColor4s", "GLshort"); 1410 glColor4s(Xen_to_C_GLshort(red), Xen_to_C_GLshort(green), Xen_to_C_GLshort(blue), Xen_to_C_GLshort(alpha)); 1411 return(Xen_false); 1412 } 1413 1414 static Xen gxg_glColor4ub(Xen red, Xen green, Xen blue, Xen alpha) 1415 { 1416 #define H_glColor4ub "void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)" 1417 Xen_check_type(Xen_is_GLubyte(red), red, 1, "glColor4ub", "GLubyte"); 1418 Xen_check_type(Xen_is_GLubyte(green), green, 2, "glColor4ub", "GLubyte"); 1419 Xen_check_type(Xen_is_GLubyte(blue), blue, 3, "glColor4ub", "GLubyte"); 1420 Xen_check_type(Xen_is_GLubyte(alpha), alpha, 4, "glColor4ub", "GLubyte"); 1421 glColor4ub(Xen_to_C_GLubyte(red), Xen_to_C_GLubyte(green), Xen_to_C_GLubyte(blue), Xen_to_C_GLubyte(alpha)); 1422 return(Xen_false); 1423 } 1424 1425 static Xen gxg_glColor4ui(Xen red, Xen green, Xen blue, Xen alpha) 1426 { 1427 #define H_glColor4ui "void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)" 1428 Xen_check_type(Xen_is_GLuint(red), red, 1, "glColor4ui", "GLuint"); 1429 Xen_check_type(Xen_is_GLuint(green), green, 2, "glColor4ui", "GLuint"); 1430 Xen_check_type(Xen_is_GLuint(blue), blue, 3, "glColor4ui", "GLuint"); 1431 Xen_check_type(Xen_is_GLuint(alpha), alpha, 4, "glColor4ui", "GLuint"); 1432 glColor4ui(Xen_to_C_GLuint(red), Xen_to_C_GLuint(green), Xen_to_C_GLuint(blue), Xen_to_C_GLuint(alpha)); 1433 return(Xen_false); 1434 } 1435 1436 static Xen gxg_glColor4us(Xen red, Xen green, Xen blue, Xen alpha) 1437 { 1438 #define H_glColor4us "void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)" 1439 Xen_check_type(Xen_is_GLushort(red), red, 1, "glColor4us", "GLushort"); 1440 Xen_check_type(Xen_is_GLushort(green), green, 2, "glColor4us", "GLushort"); 1441 Xen_check_type(Xen_is_GLushort(blue), blue, 3, "glColor4us", "GLushort"); 1442 Xen_check_type(Xen_is_GLushort(alpha), alpha, 4, "glColor4us", "GLushort"); 1443 glColor4us(Xen_to_C_GLushort(red), Xen_to_C_GLushort(green), Xen_to_C_GLushort(blue), Xen_to_C_GLushort(alpha)); 1444 return(Xen_false); 1445 } 1446 1447 static Xen gxg_glTexCoord1d(Xen s) 1448 { 1449 #define H_glTexCoord1d "void glTexCoord1d(GLdouble s)" 1450 Xen_check_type(Xen_is_GLdouble(s), s, 1, "glTexCoord1d", "GLdouble"); 1451 glTexCoord1d(Xen_to_C_GLdouble(s)); 1452 return(Xen_false); 1453 } 1454 1455 static Xen gxg_glTexCoord1f(Xen s) 1456 { 1457 #define H_glTexCoord1f "void glTexCoord1f(GLfloat s)" 1458 Xen_check_type(Xen_is_GLfloat(s), s, 1, "glTexCoord1f", "GLfloat"); 1459 glTexCoord1f(Xen_to_C_GLfloat(s)); 1460 return(Xen_false); 1461 } 1462 1463 static Xen gxg_glTexCoord1i(Xen s) 1464 { 1465 #define H_glTexCoord1i "void glTexCoord1i(GLint s)" 1466 Xen_check_type(Xen_is_GLint(s), s, 1, "glTexCoord1i", "GLint"); 1467 glTexCoord1i(Xen_to_C_GLint(s)); 1468 return(Xen_false); 1469 } 1470 1471 static Xen gxg_glTexCoord1s(Xen s) 1472 { 1473 #define H_glTexCoord1s "void glTexCoord1s(GLshort s)" 1474 Xen_check_type(Xen_is_GLshort(s), s, 1, "glTexCoord1s", "GLshort"); 1475 glTexCoord1s(Xen_to_C_GLshort(s)); 1476 return(Xen_false); 1477 } 1478 1479 static Xen gxg_glTexCoord2d(Xen s, Xen t) 1480 { 1481 #define H_glTexCoord2d "void glTexCoord2d(GLdouble s, GLdouble t)" 1482 Xen_check_type(Xen_is_GLdouble(s), s, 1, "glTexCoord2d", "GLdouble"); 1483 Xen_check_type(Xen_is_GLdouble(t), t, 2, "glTexCoord2d", "GLdouble"); 1484 glTexCoord2d(Xen_to_C_GLdouble(s), Xen_to_C_GLdouble(t)); 1485 return(Xen_false); 1486 } 1487 1488 static Xen gxg_glTexCoord2f(Xen s, Xen t) 1489 { 1490 #define H_glTexCoord2f "void glTexCoord2f(GLfloat s, GLfloat t)" 1491 Xen_check_type(Xen_is_GLfloat(s), s, 1, "glTexCoord2f", "GLfloat"); 1492 Xen_check_type(Xen_is_GLfloat(t), t, 2, "glTexCoord2f", "GLfloat"); 1493 glTexCoord2f(Xen_to_C_GLfloat(s), Xen_to_C_GLfloat(t)); 1494 return(Xen_false); 1495 } 1496 1497 static Xen gxg_glTexCoord2i(Xen s, Xen t) 1498 { 1499 #define H_glTexCoord2i "void glTexCoord2i(GLint s, GLint t)" 1500 Xen_check_type(Xen_is_GLint(s), s, 1, "glTexCoord2i", "GLint"); 1501 Xen_check_type(Xen_is_GLint(t), t, 2, "glTexCoord2i", "GLint"); 1502 glTexCoord2i(Xen_to_C_GLint(s), Xen_to_C_GLint(t)); 1503 return(Xen_false); 1504 } 1505 1506 static Xen gxg_glTexCoord2s(Xen s, Xen t) 1507 { 1508 #define H_glTexCoord2s "void glTexCoord2s(GLshort s, GLshort t)" 1509 Xen_check_type(Xen_is_GLshort(s), s, 1, "glTexCoord2s", "GLshort"); 1510 Xen_check_type(Xen_is_GLshort(t), t, 2, "glTexCoord2s", "GLshort"); 1511 glTexCoord2s(Xen_to_C_GLshort(s), Xen_to_C_GLshort(t)); 1512 return(Xen_false); 1513 } 1514 1515 static Xen gxg_glTexCoord3d(Xen s, Xen t, Xen r) 1516 { 1517 #define H_glTexCoord3d "void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)" 1518 Xen_check_type(Xen_is_GLdouble(s), s, 1, "glTexCoord3d", "GLdouble"); 1519 Xen_check_type(Xen_is_GLdouble(t), t, 2, "glTexCoord3d", "GLdouble"); 1520 Xen_check_type(Xen_is_GLdouble(r), r, 3, "glTexCoord3d", "GLdouble"); 1521 glTexCoord3d(Xen_to_C_GLdouble(s), Xen_to_C_GLdouble(t), Xen_to_C_GLdouble(r)); 1522 return(Xen_false); 1523 } 1524 1525 static Xen gxg_glTexCoord3f(Xen s, Xen t, Xen r) 1526 { 1527 #define H_glTexCoord3f "void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)" 1528 Xen_check_type(Xen_is_GLfloat(s), s, 1, "glTexCoord3f", "GLfloat"); 1529 Xen_check_type(Xen_is_GLfloat(t), t, 2, "glTexCoord3f", "GLfloat"); 1530 Xen_check_type(Xen_is_GLfloat(r), r, 3, "glTexCoord3f", "GLfloat"); 1531 glTexCoord3f(Xen_to_C_GLfloat(s), Xen_to_C_GLfloat(t), Xen_to_C_GLfloat(r)); 1532 return(Xen_false); 1533 } 1534 1535 static Xen gxg_glTexCoord3i(Xen s, Xen t, Xen r) 1536 { 1537 #define H_glTexCoord3i "void glTexCoord3i(GLint s, GLint t, GLint r)" 1538 Xen_check_type(Xen_is_GLint(s), s, 1, "glTexCoord3i", "GLint"); 1539 Xen_check_type(Xen_is_GLint(t), t, 2, "glTexCoord3i", "GLint"); 1540 Xen_check_type(Xen_is_GLint(r), r, 3, "glTexCoord3i", "GLint"); 1541 glTexCoord3i(Xen_to_C_GLint(s), Xen_to_C_GLint(t), Xen_to_C_GLint(r)); 1542 return(Xen_false); 1543 } 1544 1545 static Xen gxg_glTexCoord3s(Xen s, Xen t, Xen r) 1546 { 1547 #define H_glTexCoord3s "void glTexCoord3s(GLshort s, GLshort t, GLshort r)" 1548 Xen_check_type(Xen_is_GLshort(s), s, 1, "glTexCoord3s", "GLshort"); 1549 Xen_check_type(Xen_is_GLshort(t), t, 2, "glTexCoord3s", "GLshort"); 1550 Xen_check_type(Xen_is_GLshort(r), r, 3, "glTexCoord3s", "GLshort"); 1551 glTexCoord3s(Xen_to_C_GLshort(s), Xen_to_C_GLshort(t), Xen_to_C_GLshort(r)); 1552 return(Xen_false); 1553 } 1554 1555 static Xen gxg_glTexCoord4d(Xen s, Xen t, Xen r, Xen q) 1556 { 1557 #define H_glTexCoord4d "void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)" 1558 Xen_check_type(Xen_is_GLdouble(s), s, 1, "glTexCoord4d", "GLdouble"); 1559 Xen_check_type(Xen_is_GLdouble(t), t, 2, "glTexCoord4d", "GLdouble"); 1560 Xen_check_type(Xen_is_GLdouble(r), r, 3, "glTexCoord4d", "GLdouble"); 1561 Xen_check_type(Xen_is_GLdouble(q), q, 4, "glTexCoord4d", "GLdouble"); 1562 glTexCoord4d(Xen_to_C_GLdouble(s), Xen_to_C_GLdouble(t), Xen_to_C_GLdouble(r), Xen_to_C_GLdouble(q)); 1563 return(Xen_false); 1564 } 1565 1566 static Xen gxg_glTexCoord4f(Xen s, Xen t, Xen r, Xen q) 1567 { 1568 #define H_glTexCoord4f "void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)" 1569 Xen_check_type(Xen_is_GLfloat(s), s, 1, "glTexCoord4f", "GLfloat"); 1570 Xen_check_type(Xen_is_GLfloat(t), t, 2, "glTexCoord4f", "GLfloat"); 1571 Xen_check_type(Xen_is_GLfloat(r), r, 3, "glTexCoord4f", "GLfloat"); 1572 Xen_check_type(Xen_is_GLfloat(q), q, 4, "glTexCoord4f", "GLfloat"); 1573 glTexCoord4f(Xen_to_C_GLfloat(s), Xen_to_C_GLfloat(t), Xen_to_C_GLfloat(r), Xen_to_C_GLfloat(q)); 1574 return(Xen_false); 1575 } 1576 1577 static Xen gxg_glTexCoord4i(Xen s, Xen t, Xen r, Xen q) 1578 { 1579 #define H_glTexCoord4i "void glTexCoord4i(GLint s, GLint t, GLint r, GLint q)" 1580 Xen_check_type(Xen_is_GLint(s), s, 1, "glTexCoord4i", "GLint"); 1581 Xen_check_type(Xen_is_GLint(t), t, 2, "glTexCoord4i", "GLint"); 1582 Xen_check_type(Xen_is_GLint(r), r, 3, "glTexCoord4i", "GLint"); 1583 Xen_check_type(Xen_is_GLint(q), q, 4, "glTexCoord4i", "GLint"); 1584 glTexCoord4i(Xen_to_C_GLint(s), Xen_to_C_GLint(t), Xen_to_C_GLint(r), Xen_to_C_GLint(q)); 1585 return(Xen_false); 1586 } 1587 1588 static Xen gxg_glTexCoord4s(Xen s, Xen t, Xen r, Xen q) 1589 { 1590 #define H_glTexCoord4s "void glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)" 1591 Xen_check_type(Xen_is_GLshort(s), s, 1, "glTexCoord4s", "GLshort"); 1592 Xen_check_type(Xen_is_GLshort(t), t, 2, "glTexCoord4s", "GLshort"); 1593 Xen_check_type(Xen_is_GLshort(r), r, 3, "glTexCoord4s", "GLshort"); 1594 Xen_check_type(Xen_is_GLshort(q), q, 4, "glTexCoord4s", "GLshort"); 1595 glTexCoord4s(Xen_to_C_GLshort(s), Xen_to_C_GLshort(t), Xen_to_C_GLshort(r), Xen_to_C_GLshort(q)); 1596 return(Xen_false); 1597 } 1598 1599 static Xen gxg_glRasterPos2d(Xen x, Xen y) 1600 { 1601 #define H_glRasterPos2d "void glRasterPos2d(GLdouble x, GLdouble y)" 1602 Xen_check_type(Xen_is_GLdouble(x), x, 1, "glRasterPos2d", "GLdouble"); 1603 Xen_check_type(Xen_is_GLdouble(y), y, 2, "glRasterPos2d", "GLdouble"); 1604 glRasterPos2d(Xen_to_C_GLdouble(x), Xen_to_C_GLdouble(y)); 1605 return(Xen_false); 1606 } 1607 1608 static Xen gxg_glRasterPos2f(Xen x, Xen y) 1609 { 1610 #define H_glRasterPos2f "void glRasterPos2f(GLfloat x, GLfloat y)" 1611 Xen_check_type(Xen_is_GLfloat(x), x, 1, "glRasterPos2f", "GLfloat"); 1612 Xen_check_type(Xen_is_GLfloat(y), y, 2, "glRasterPos2f", "GLfloat"); 1613 glRasterPos2f(Xen_to_C_GLfloat(x), Xen_to_C_GLfloat(y)); 1614 return(Xen_false); 1615 } 1616 1617 static Xen gxg_glRasterPos2i(Xen x, Xen y) 1618 { 1619 #define H_glRasterPos2i "void glRasterPos2i(GLint x, GLint y)" 1620 Xen_check_type(Xen_is_GLint(x), x, 1, "glRasterPos2i", "GLint"); 1621 Xen_check_type(Xen_is_GLint(y), y, 2, "glRasterPos2i", "GLint"); 1622 glRasterPos2i(Xen_to_C_GLint(x), Xen_to_C_GLint(y)); 1623 return(Xen_false); 1624 } 1625 1626 static Xen gxg_glRasterPos2s(Xen x, Xen y) 1627 { 1628 #define H_glRasterPos2s "void glRasterPos2s(GLshort x, GLshort y)" 1629 Xen_check_type(Xen_is_GLshort(x), x, 1, "glRasterPos2s", "GLshort"); 1630 Xen_check_type(Xen_is_GLshort(y), y, 2, "glRasterPos2s", "GLshort"); 1631 glRasterPos2s(Xen_to_C_GLshort(x), Xen_to_C_GLshort(y)); 1632 return(Xen_false); 1633 } 1634 1635 static Xen gxg_glRasterPos3d(Xen x, Xen y, Xen z) 1636 { 1637 #define H_glRasterPos3d "void glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)" 1638 Xen_check_type(Xen_is_GLdouble(x), x, 1, "glRasterPos3d", "GLdouble"); 1639 Xen_check_type(Xen_is_GLdouble(y), y, 2, "glRasterPos3d", "GLdouble"); 1640 Xen_check_type(Xen_is_GLdouble(z), z, 3, "glRasterPos3d", "GLdouble"); 1641 glRasterPos3d(Xen_to_C_GLdouble(x), Xen_to_C_GLdouble(y), Xen_to_C_GLdouble(z)); 1642 return(Xen_false); 1643 } 1644 1645 static Xen gxg_glRasterPos3f(Xen x, Xen y, Xen z) 1646 { 1647 #define H_glRasterPos3f "void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)" 1648 Xen_check_type(Xen_is_GLfloat(x), x, 1, "glRasterPos3f", "GLfloat"); 1649 Xen_check_type(Xen_is_GLfloat(y), y, 2, "glRasterPos3f", "GLfloat"); 1650 Xen_check_type(Xen_is_GLfloat(z), z, 3, "glRasterPos3f", "GLfloat"); 1651 glRasterPos3f(Xen_to_C_GLfloat(x), Xen_to_C_GLfloat(y), Xen_to_C_GLfloat(z)); 1652 return(Xen_false); 1653 } 1654 1655 static Xen gxg_glRasterPos3i(Xen x, Xen y, Xen z) 1656 { 1657 #define H_glRasterPos3i "void glRasterPos3i(GLint x, GLint y, GLint z)" 1658 Xen_check_type(Xen_is_GLint(x), x, 1, "glRasterPos3i", "GLint"); 1659 Xen_check_type(Xen_is_GLint(y), y, 2, "glRasterPos3i", "GLint"); 1660 Xen_check_type(Xen_is_GLint(z), z, 3, "glRasterPos3i", "GLint"); 1661 glRasterPos3i(Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLint(z)); 1662 return(Xen_false); 1663 } 1664 1665 static Xen gxg_glRasterPos3s(Xen x, Xen y, Xen z) 1666 { 1667 #define H_glRasterPos3s "void glRasterPos3s(GLshort x, GLshort y, GLshort z)" 1668 Xen_check_type(Xen_is_GLshort(x), x, 1, "glRasterPos3s", "GLshort"); 1669 Xen_check_type(Xen_is_GLshort(y), y, 2, "glRasterPos3s", "GLshort"); 1670 Xen_check_type(Xen_is_GLshort(z), z, 3, "glRasterPos3s", "GLshort"); 1671 glRasterPos3s(Xen_to_C_GLshort(x), Xen_to_C_GLshort(y), Xen_to_C_GLshort(z)); 1672 return(Xen_false); 1673 } 1674 1675 static Xen gxg_glRasterPos4d(Xen x, Xen y, Xen z, Xen w) 1676 { 1677 #define H_glRasterPos4d "void glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)" 1678 Xen_check_type(Xen_is_GLdouble(x), x, 1, "glRasterPos4d", "GLdouble"); 1679 Xen_check_type(Xen_is_GLdouble(y), y, 2, "glRasterPos4d", "GLdouble"); 1680 Xen_check_type(Xen_is_GLdouble(z), z, 3, "glRasterPos4d", "GLdouble"); 1681 Xen_check_type(Xen_is_GLdouble(w), w, 4, "glRasterPos4d", "GLdouble"); 1682 glRasterPos4d(Xen_to_C_GLdouble(x), Xen_to_C_GLdouble(y), Xen_to_C_GLdouble(z), Xen_to_C_GLdouble(w)); 1683 return(Xen_false); 1684 } 1685 1686 static Xen gxg_glRasterPos4f(Xen x, Xen y, Xen z, Xen w) 1687 { 1688 #define H_glRasterPos4f "void glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)" 1689 Xen_check_type(Xen_is_GLfloat(x), x, 1, "glRasterPos4f", "GLfloat"); 1690 Xen_check_type(Xen_is_GLfloat(y), y, 2, "glRasterPos4f", "GLfloat"); 1691 Xen_check_type(Xen_is_GLfloat(z), z, 3, "glRasterPos4f", "GLfloat"); 1692 Xen_check_type(Xen_is_GLfloat(w), w, 4, "glRasterPos4f", "GLfloat"); 1693 glRasterPos4f(Xen_to_C_GLfloat(x), Xen_to_C_GLfloat(y), Xen_to_C_GLfloat(z), Xen_to_C_GLfloat(w)); 1694 return(Xen_false); 1695 } 1696 1697 static Xen gxg_glRasterPos4i(Xen x, Xen y, Xen z, Xen w) 1698 { 1699 #define H_glRasterPos4i "void glRasterPos4i(GLint x, GLint y, GLint z, GLint w)" 1700 Xen_check_type(Xen_is_GLint(x), x, 1, "glRasterPos4i", "GLint"); 1701 Xen_check_type(Xen_is_GLint(y), y, 2, "glRasterPos4i", "GLint"); 1702 Xen_check_type(Xen_is_GLint(z), z, 3, "glRasterPos4i", "GLint"); 1703 Xen_check_type(Xen_is_GLint(w), w, 4, "glRasterPos4i", "GLint"); 1704 glRasterPos4i(Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLint(z), Xen_to_C_GLint(w)); 1705 return(Xen_false); 1706 } 1707 1708 static Xen gxg_glRasterPos4s(Xen x, Xen y, Xen z, Xen w) 1709 { 1710 #define H_glRasterPos4s "void glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)" 1711 Xen_check_type(Xen_is_GLshort(x), x, 1, "glRasterPos4s", "GLshort"); 1712 Xen_check_type(Xen_is_GLshort(y), y, 2, "glRasterPos4s", "GLshort"); 1713 Xen_check_type(Xen_is_GLshort(z), z, 3, "glRasterPos4s", "GLshort"); 1714 Xen_check_type(Xen_is_GLshort(w), w, 4, "glRasterPos4s", "GLshort"); 1715 glRasterPos4s(Xen_to_C_GLshort(x), Xen_to_C_GLshort(y), Xen_to_C_GLshort(z), Xen_to_C_GLshort(w)); 1716 return(Xen_false); 1717 } 1718 1719 static Xen gxg_glRectd(Xen x1, Xen y1, Xen x2, Xen y2) 1720 { 1721 #define H_glRectd "void glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)" 1722 Xen_check_type(Xen_is_GLdouble(x1), x1, 1, "glRectd", "GLdouble"); 1723 Xen_check_type(Xen_is_GLdouble(y1), y1, 2, "glRectd", "GLdouble"); 1724 Xen_check_type(Xen_is_GLdouble(x2), x2, 3, "glRectd", "GLdouble"); 1725 Xen_check_type(Xen_is_GLdouble(y2), y2, 4, "glRectd", "GLdouble"); 1726 glRectd(Xen_to_C_GLdouble(x1), Xen_to_C_GLdouble(y1), Xen_to_C_GLdouble(x2), Xen_to_C_GLdouble(y2)); 1727 return(Xen_false); 1728 } 1729 1730 static Xen gxg_glRectf(Xen x1, Xen y1, Xen x2, Xen y2) 1731 { 1732 #define H_glRectf "void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)" 1733 Xen_check_type(Xen_is_GLfloat(x1), x1, 1, "glRectf", "GLfloat"); 1734 Xen_check_type(Xen_is_GLfloat(y1), y1, 2, "glRectf", "GLfloat"); 1735 Xen_check_type(Xen_is_GLfloat(x2), x2, 3, "glRectf", "GLfloat"); 1736 Xen_check_type(Xen_is_GLfloat(y2), y2, 4, "glRectf", "GLfloat"); 1737 glRectf(Xen_to_C_GLfloat(x1), Xen_to_C_GLfloat(y1), Xen_to_C_GLfloat(x2), Xen_to_C_GLfloat(y2)); 1738 return(Xen_false); 1739 } 1740 1741 static Xen gxg_glRecti(Xen x1, Xen y1, Xen x2, Xen y2) 1742 { 1743 #define H_glRecti "void glRecti(GLint x1, GLint y1, GLint x2, GLint y2)" 1744 Xen_check_type(Xen_is_GLint(x1), x1, 1, "glRecti", "GLint"); 1745 Xen_check_type(Xen_is_GLint(y1), y1, 2, "glRecti", "GLint"); 1746 Xen_check_type(Xen_is_GLint(x2), x2, 3, "glRecti", "GLint"); 1747 Xen_check_type(Xen_is_GLint(y2), y2, 4, "glRecti", "GLint"); 1748 glRecti(Xen_to_C_GLint(x1), Xen_to_C_GLint(y1), Xen_to_C_GLint(x2), Xen_to_C_GLint(y2)); 1749 return(Xen_false); 1750 } 1751 1752 static Xen gxg_glRects(Xen x1, Xen y1, Xen x2, Xen y2) 1753 { 1754 #define H_glRects "void glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)" 1755 Xen_check_type(Xen_is_GLshort(x1), x1, 1, "glRects", "GLshort"); 1756 Xen_check_type(Xen_is_GLshort(y1), y1, 2, "glRects", "GLshort"); 1757 Xen_check_type(Xen_is_GLshort(x2), x2, 3, "glRects", "GLshort"); 1758 Xen_check_type(Xen_is_GLshort(y2), y2, 4, "glRects", "GLshort"); 1759 glRects(Xen_to_C_GLshort(x1), Xen_to_C_GLshort(y1), Xen_to_C_GLshort(x2), Xen_to_C_GLshort(y2)); 1760 return(Xen_false); 1761 } 1762 1763 static Xen gxg_glVertexPointer(Xen size, Xen type, Xen stride, Xen ptr) 1764 { 1765 #define H_glVertexPointer "void glVertexPointer(GLint size, GLenum type, GLsizei stride, GLvoid* ptr)" 1766 Xen_check_type(Xen_is_GLint(size), size, 1, "glVertexPointer", "GLint"); 1767 Xen_check_type(Xen_is_GLenum(type), type, 2, "glVertexPointer", "GLenum"); 1768 Xen_check_type(Xen_is_GLsizei(stride), stride, 3, "glVertexPointer", "GLsizei"); 1769 Xen_check_type(Xen_is_GLvoid_(ptr), ptr, 4, "glVertexPointer", "GLvoid*"); 1770 glVertexPointer(Xen_to_C_GLint(size), Xen_to_C_GLenum(type), Xen_to_C_GLsizei(stride), Xen_to_C_GLvoid_(ptr)); 1771 return(Xen_false); 1772 } 1773 1774 static Xen gxg_glNormalPointer(Xen type, Xen stride, Xen ptr) 1775 { 1776 #define H_glNormalPointer "void glNormalPointer(GLenum type, GLsizei stride, GLvoid* ptr)" 1777 Xen_check_type(Xen_is_GLenum(type), type, 1, "glNormalPointer", "GLenum"); 1778 Xen_check_type(Xen_is_GLsizei(stride), stride, 2, "glNormalPointer", "GLsizei"); 1779 Xen_check_type(Xen_is_GLvoid_(ptr), ptr, 3, "glNormalPointer", "GLvoid*"); 1780 glNormalPointer(Xen_to_C_GLenum(type), Xen_to_C_GLsizei(stride), Xen_to_C_GLvoid_(ptr)); 1781 return(Xen_false); 1782 } 1783 1784 static Xen gxg_glColorPointer(Xen size, Xen type, Xen stride, Xen ptr) 1785 { 1786 #define H_glColorPointer "void glColorPointer(GLint size, GLenum type, GLsizei stride, GLvoid* ptr)" 1787 Xen_check_type(Xen_is_GLint(size), size, 1, "glColorPointer", "GLint"); 1788 Xen_check_type(Xen_is_GLenum(type), type, 2, "glColorPointer", "GLenum"); 1789 Xen_check_type(Xen_is_GLsizei(stride), stride, 3, "glColorPointer", "GLsizei"); 1790 Xen_check_type(Xen_is_GLvoid_(ptr), ptr, 4, "glColorPointer", "GLvoid*"); 1791 glColorPointer(Xen_to_C_GLint(size), Xen_to_C_GLenum(type), Xen_to_C_GLsizei(stride), Xen_to_C_GLvoid_(ptr)); 1792 return(Xen_false); 1793 } 1794 1795 static Xen gxg_glIndexPointer(Xen type, Xen stride, Xen ptr) 1796 { 1797 #define H_glIndexPointer "void glIndexPointer(GLenum type, GLsizei stride, GLvoid* ptr)" 1798 Xen_check_type(Xen_is_GLenum(type), type, 1, "glIndexPointer", "GLenum"); 1799 Xen_check_type(Xen_is_GLsizei(stride), stride, 2, "glIndexPointer", "GLsizei"); 1800 Xen_check_type(Xen_is_GLvoid_(ptr), ptr, 3, "glIndexPointer", "GLvoid*"); 1801 glIndexPointer(Xen_to_C_GLenum(type), Xen_to_C_GLsizei(stride), Xen_to_C_GLvoid_(ptr)); 1802 return(Xen_false); 1803 } 1804 1805 static Xen gxg_glTexCoordPointer(Xen size, Xen type, Xen stride, Xen ptr) 1806 { 1807 #define H_glTexCoordPointer "void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, GLvoid* ptr)" 1808 Xen_check_type(Xen_is_GLint(size), size, 1, "glTexCoordPointer", "GLint"); 1809 Xen_check_type(Xen_is_GLenum(type), type, 2, "glTexCoordPointer", "GLenum"); 1810 Xen_check_type(Xen_is_GLsizei(stride), stride, 3, "glTexCoordPointer", "GLsizei"); 1811 Xen_check_type(Xen_is_GLvoid_(ptr), ptr, 4, "glTexCoordPointer", "GLvoid*"); 1812 glTexCoordPointer(Xen_to_C_GLint(size), Xen_to_C_GLenum(type), Xen_to_C_GLsizei(stride), Xen_to_C_GLvoid_(ptr)); 1813 return(Xen_false); 1814 } 1815 1816 static Xen gxg_glEdgeFlagPointer(Xen stride, Xen ptr) 1817 { 1818 #define H_glEdgeFlagPointer "void glEdgeFlagPointer(GLsizei stride, GLvoid* ptr)" 1819 Xen_check_type(Xen_is_GLsizei(stride), stride, 1, "glEdgeFlagPointer", "GLsizei"); 1820 Xen_check_type(Xen_is_GLvoid_(ptr), ptr, 2, "glEdgeFlagPointer", "GLvoid*"); 1821 glEdgeFlagPointer(Xen_to_C_GLsizei(stride), Xen_to_C_GLvoid_(ptr)); 1822 return(Xen_false); 1823 } 1824 1825 static Xen gxg_glGetPointerv(Xen pname, Xen params) 1826 { 1827 #define H_glGetPointerv "void glGetPointerv(GLenum pname, void** [params])" 1828 void* ref_params[1]; 1829 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glGetPointerv", "GLenum"); 1830 glGetPointerv(Xen_to_C_GLenum(pname), ref_params); 1831 return(Xen_list_1(C_to_Xen_void_(ref_params[0]))); 1832 } 1833 1834 static Xen gxg_glArrayElement(Xen i) 1835 { 1836 #define H_glArrayElement "void glArrayElement(GLint i)" 1837 Xen_check_type(Xen_is_GLint(i), i, 1, "glArrayElement", "GLint"); 1838 glArrayElement(Xen_to_C_GLint(i)); 1839 return(Xen_false); 1840 } 1841 1842 static Xen gxg_glDrawArrays(Xen mode, Xen first, Xen count) 1843 { 1844 #define H_glDrawArrays "void glDrawArrays(GLenum mode, GLint first, GLsizei count)" 1845 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glDrawArrays", "GLenum"); 1846 Xen_check_type(Xen_is_GLint(first), first, 2, "glDrawArrays", "GLint"); 1847 Xen_check_type(Xen_is_GLsizei(count), count, 3, "glDrawArrays", "GLsizei"); 1848 glDrawArrays(Xen_to_C_GLenum(mode), Xen_to_C_GLint(first), Xen_to_C_GLsizei(count)); 1849 return(Xen_false); 1850 } 1851 1852 static Xen gxg_glDrawElements(Xen mode, Xen count, Xen type, Xen indices) 1853 { 1854 #define H_glDrawElements "void glDrawElements(GLenum mode, GLsizei count, GLenum type, GLvoid* indices)" 1855 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glDrawElements", "GLenum"); 1856 Xen_check_type(Xen_is_GLsizei(count), count, 2, "glDrawElements", "GLsizei"); 1857 Xen_check_type(Xen_is_GLenum(type), type, 3, "glDrawElements", "GLenum"); 1858 Xen_check_type(Xen_is_GLvoid_(indices), indices, 4, "glDrawElements", "GLvoid*"); 1859 glDrawElements(Xen_to_C_GLenum(mode), Xen_to_C_GLsizei(count), Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(indices)); 1860 return(Xen_false); 1861 } 1862 1863 static Xen gxg_glInterleavedArrays(Xen format, Xen stride, Xen pointer) 1864 { 1865 #define H_glInterleavedArrays "void glInterleavedArrays(GLenum format, GLsizei stride, GLvoid* pointer)" 1866 Xen_check_type(Xen_is_GLenum(format), format, 1, "glInterleavedArrays", "GLenum"); 1867 Xen_check_type(Xen_is_GLsizei(stride), stride, 2, "glInterleavedArrays", "GLsizei"); 1868 Xen_check_type(Xen_is_GLvoid_(pointer), pointer, 3, "glInterleavedArrays", "GLvoid*"); 1869 glInterleavedArrays(Xen_to_C_GLenum(format), Xen_to_C_GLsizei(stride), Xen_to_C_GLvoid_(pointer)); 1870 return(Xen_false); 1871 } 1872 1873 static Xen gxg_glShadeModel(Xen mode) 1874 { 1875 #define H_glShadeModel "void glShadeModel(GLenum mode)" 1876 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glShadeModel", "GLenum"); 1877 glShadeModel(Xen_to_C_GLenum(mode)); 1878 return(Xen_false); 1879 } 1880 1881 static Xen gxg_glLightf(Xen light, Xen pname, Xen param) 1882 { 1883 #define H_glLightf "void glLightf(GLenum light, GLenum pname, GLfloat param)" 1884 Xen_check_type(Xen_is_GLenum(light), light, 1, "glLightf", "GLenum"); 1885 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glLightf", "GLenum"); 1886 Xen_check_type(Xen_is_GLfloat(param), param, 3, "glLightf", "GLfloat"); 1887 glLightf(Xen_to_C_GLenum(light), Xen_to_C_GLenum(pname), Xen_to_C_GLfloat(param)); 1888 return(Xen_false); 1889 } 1890 1891 static Xen gxg_glLighti(Xen light, Xen pname, Xen param) 1892 { 1893 #define H_glLighti "void glLighti(GLenum light, GLenum pname, GLint param)" 1894 Xen_check_type(Xen_is_GLenum(light), light, 1, "glLighti", "GLenum"); 1895 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glLighti", "GLenum"); 1896 Xen_check_type(Xen_is_GLint(param), param, 3, "glLighti", "GLint"); 1897 glLighti(Xen_to_C_GLenum(light), Xen_to_C_GLenum(pname), Xen_to_C_GLint(param)); 1898 return(Xen_false); 1899 } 1900 1901 static Xen gxg_glGetLightfv(Xen light, Xen pname, Xen params) 1902 { 1903 #define H_glGetLightfv "void glGetLightfv(GLenum light, GLenum pname, GLfloat* [params])" 1904 GLfloat ref_params[16]; 1905 Xen_check_type(Xen_is_GLenum(light), light, 1, "glGetLightfv", "GLenum"); 1906 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetLightfv", "GLenum"); 1907 glGetLightfv(Xen_to_C_GLenum(light), Xen_to_C_GLenum(pname), ref_params); 1908 { 1909 Xen result; 1910 int i, vals; 1911 vals = how_many_vals(Xen_to_C_GLenum(pname)); 1912 result = Xen_empty_list; 1913 for (i = 0; i < vals; i++) 1914 result = Xen_cons(C_to_Xen_GLfloat(ref_params[i]), result); 1915 return(result); 1916 } 1917 } 1918 1919 static Xen gxg_glGetLightiv(Xen light, Xen pname, Xen params) 1920 { 1921 #define H_glGetLightiv "void glGetLightiv(GLenum light, GLenum pname, GLint* [params])" 1922 GLint ref_params[1]; 1923 Xen_check_type(Xen_is_GLenum(light), light, 1, "glGetLightiv", "GLenum"); 1924 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetLightiv", "GLenum"); 1925 glGetLightiv(Xen_to_C_GLenum(light), Xen_to_C_GLenum(pname), ref_params); 1926 return(Xen_list_1(C_to_Xen_GLint(ref_params[0]))); 1927 } 1928 1929 static Xen gxg_glLightModelf(Xen pname, Xen param) 1930 { 1931 #define H_glLightModelf "void glLightModelf(GLenum pname, GLfloat param)" 1932 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glLightModelf", "GLenum"); 1933 Xen_check_type(Xen_is_GLfloat(param), param, 2, "glLightModelf", "GLfloat"); 1934 glLightModelf(Xen_to_C_GLenum(pname), Xen_to_C_GLfloat(param)); 1935 return(Xen_false); 1936 } 1937 1938 static Xen gxg_glLightModeli(Xen pname, Xen param) 1939 { 1940 #define H_glLightModeli "void glLightModeli(GLenum pname, GLint param)" 1941 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glLightModeli", "GLenum"); 1942 Xen_check_type(Xen_is_GLint(param), param, 2, "glLightModeli", "GLint"); 1943 glLightModeli(Xen_to_C_GLenum(pname), Xen_to_C_GLint(param)); 1944 return(Xen_false); 1945 } 1946 1947 static Xen gxg_glMaterialf(Xen face, Xen pname, Xen param) 1948 { 1949 #define H_glMaterialf "void glMaterialf(GLenum face, GLenum pname, GLfloat param)" 1950 Xen_check_type(Xen_is_GLenum(face), face, 1, "glMaterialf", "GLenum"); 1951 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glMaterialf", "GLenum"); 1952 Xen_check_type(Xen_is_GLfloat(param), param, 3, "glMaterialf", "GLfloat"); 1953 glMaterialf(Xen_to_C_GLenum(face), Xen_to_C_GLenum(pname), Xen_to_C_GLfloat(param)); 1954 return(Xen_false); 1955 } 1956 1957 static Xen gxg_glMateriali(Xen face, Xen pname, Xen param) 1958 { 1959 #define H_glMateriali "void glMateriali(GLenum face, GLenum pname, GLint param)" 1960 Xen_check_type(Xen_is_GLenum(face), face, 1, "glMateriali", "GLenum"); 1961 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glMateriali", "GLenum"); 1962 Xen_check_type(Xen_is_GLint(param), param, 3, "glMateriali", "GLint"); 1963 glMateriali(Xen_to_C_GLenum(face), Xen_to_C_GLenum(pname), Xen_to_C_GLint(param)); 1964 return(Xen_false); 1965 } 1966 1967 static Xen gxg_glGetMaterialfv(Xen face, Xen pname, Xen params) 1968 { 1969 #define H_glGetMaterialfv "void glGetMaterialfv(GLenum face, GLenum pname, GLfloat* [params])" 1970 GLfloat ref_params[16]; 1971 Xen_check_type(Xen_is_GLenum(face), face, 1, "glGetMaterialfv", "GLenum"); 1972 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetMaterialfv", "GLenum"); 1973 glGetMaterialfv(Xen_to_C_GLenum(face), Xen_to_C_GLenum(pname), ref_params); 1974 { 1975 Xen result; 1976 int i, vals; 1977 vals = how_many_vals(Xen_to_C_GLenum(pname)); 1978 result = Xen_empty_list; 1979 for (i = 0; i < vals; i++) 1980 result = Xen_cons(C_to_Xen_GLfloat(ref_params[i]), result); 1981 return(result); 1982 } 1983 } 1984 1985 static Xen gxg_glGetMaterialiv(Xen face, Xen pname, Xen params) 1986 { 1987 #define H_glGetMaterialiv "void glGetMaterialiv(GLenum face, GLenum pname, GLint* [params])" 1988 GLint ref_params[1]; 1989 Xen_check_type(Xen_is_GLenum(face), face, 1, "glGetMaterialiv", "GLenum"); 1990 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetMaterialiv", "GLenum"); 1991 glGetMaterialiv(Xen_to_C_GLenum(face), Xen_to_C_GLenum(pname), ref_params); 1992 return(Xen_list_1(C_to_Xen_GLint(ref_params[0]))); 1993 } 1994 1995 static Xen gxg_glColorMaterial(Xen face, Xen mode) 1996 { 1997 #define H_glColorMaterial "void glColorMaterial(GLenum face, GLenum mode)" 1998 Xen_check_type(Xen_is_GLenum(face), face, 1, "glColorMaterial", "GLenum"); 1999 Xen_check_type(Xen_is_GLenum(mode), mode, 2, "glColorMaterial", "GLenum"); 2000 glColorMaterial(Xen_to_C_GLenum(face), Xen_to_C_GLenum(mode)); 2001 return(Xen_false); 2002 } 2003 2004 static Xen gxg_glPixelZoom(Xen xfactor, Xen yfactor) 2005 { 2006 #define H_glPixelZoom "void glPixelZoom(GLfloat xfactor, GLfloat yfactor)" 2007 Xen_check_type(Xen_is_GLfloat(xfactor), xfactor, 1, "glPixelZoom", "GLfloat"); 2008 Xen_check_type(Xen_is_GLfloat(yfactor), yfactor, 2, "glPixelZoom", "GLfloat"); 2009 glPixelZoom(Xen_to_C_GLfloat(xfactor), Xen_to_C_GLfloat(yfactor)); 2010 return(Xen_false); 2011 } 2012 2013 static Xen gxg_glPixelStoref(Xen pname, Xen param) 2014 { 2015 #define H_glPixelStoref "void glPixelStoref(GLenum pname, GLfloat param)" 2016 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glPixelStoref", "GLenum"); 2017 Xen_check_type(Xen_is_GLfloat(param), param, 2, "glPixelStoref", "GLfloat"); 2018 glPixelStoref(Xen_to_C_GLenum(pname), Xen_to_C_GLfloat(param)); 2019 return(Xen_false); 2020 } 2021 2022 static Xen gxg_glPixelStorei(Xen pname, Xen param) 2023 { 2024 #define H_glPixelStorei "void glPixelStorei(GLenum pname, GLint param)" 2025 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glPixelStorei", "GLenum"); 2026 Xen_check_type(Xen_is_GLint(param), param, 2, "glPixelStorei", "GLint"); 2027 glPixelStorei(Xen_to_C_GLenum(pname), Xen_to_C_GLint(param)); 2028 return(Xen_false); 2029 } 2030 2031 static Xen gxg_glPixelTransferf(Xen pname, Xen param) 2032 { 2033 #define H_glPixelTransferf "void glPixelTransferf(GLenum pname, GLfloat param)" 2034 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glPixelTransferf", "GLenum"); 2035 Xen_check_type(Xen_is_GLfloat(param), param, 2, "glPixelTransferf", "GLfloat"); 2036 glPixelTransferf(Xen_to_C_GLenum(pname), Xen_to_C_GLfloat(param)); 2037 return(Xen_false); 2038 } 2039 2040 static Xen gxg_glPixelTransferi(Xen pname, Xen param) 2041 { 2042 #define H_glPixelTransferi "void glPixelTransferi(GLenum pname, GLint param)" 2043 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glPixelTransferi", "GLenum"); 2044 Xen_check_type(Xen_is_GLint(param), param, 2, "glPixelTransferi", "GLint"); 2045 glPixelTransferi(Xen_to_C_GLenum(pname), Xen_to_C_GLint(param)); 2046 return(Xen_false); 2047 } 2048 2049 static Xen gxg_glGetPixelMapfv(Xen map, Xen values) 2050 { 2051 #define H_glGetPixelMapfv "void glGetPixelMapfv(GLenum map, GLfloat* [values])" 2052 GLfloat ref_values[1]; 2053 Xen_check_type(Xen_is_GLenum(map), map, 1, "glGetPixelMapfv", "GLenum"); 2054 glGetPixelMapfv(Xen_to_C_GLenum(map), ref_values); 2055 return(Xen_list_1(C_to_Xen_GLfloat(ref_values[0]))); 2056 } 2057 2058 static Xen gxg_glGetPixelMapuiv(Xen map, Xen values) 2059 { 2060 #define H_glGetPixelMapuiv "void glGetPixelMapuiv(GLenum map, GLuint* [values])" 2061 GLuint ref_values[1]; 2062 Xen_check_type(Xen_is_GLenum(map), map, 1, "glGetPixelMapuiv", "GLenum"); 2063 glGetPixelMapuiv(Xen_to_C_GLenum(map), ref_values); 2064 return(Xen_list_1(C_to_Xen_GLuint(ref_values[0]))); 2065 } 2066 2067 static Xen gxg_glGetPixelMapusv(Xen map, Xen values) 2068 { 2069 #define H_glGetPixelMapusv "void glGetPixelMapusv(GLenum map, GLushort* [values])" 2070 GLushort ref_values[1]; 2071 Xen_check_type(Xen_is_GLenum(map), map, 1, "glGetPixelMapusv", "GLenum"); 2072 glGetPixelMapusv(Xen_to_C_GLenum(map), ref_values); 2073 return(Xen_list_1(C_to_Xen_GLushort(ref_values[0]))); 2074 } 2075 2076 static Xen gxg_glBitmap(Xen width, Xen height, Xen xorig, Xen yorig, Xen xmove, Xen ymove, Xen bitmap) 2077 { 2078 #define H_glBitmap "void glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, \ 2079 GLfloat ymove, GLubyte* bitmap)" 2080 Xen_check_type(Xen_is_GLsizei(width), width, 1, "glBitmap", "GLsizei"); 2081 Xen_check_type(Xen_is_GLsizei(height), height, 2, "glBitmap", "GLsizei"); 2082 Xen_check_type(Xen_is_GLfloat(xorig), xorig, 3, "glBitmap", "GLfloat"); 2083 Xen_check_type(Xen_is_GLfloat(yorig), yorig, 4, "glBitmap", "GLfloat"); 2084 Xen_check_type(Xen_is_GLfloat(xmove), xmove, 5, "glBitmap", "GLfloat"); 2085 Xen_check_type(Xen_is_GLfloat(ymove), ymove, 6, "glBitmap", "GLfloat"); 2086 Xen_check_type(Xen_is_GLubyte_(bitmap), bitmap, 7, "glBitmap", "GLubyte*"); 2087 glBitmap(Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height), Xen_to_C_GLfloat(xorig), Xen_to_C_GLfloat(yorig), Xen_to_C_GLfloat(xmove), 2088 Xen_to_C_GLfloat(ymove), Xen_to_C_GLubyte_(bitmap)); 2089 return(Xen_false); 2090 } 2091 2092 static Xen gxg_glReadPixels(Xen x, Xen y, Xen width, Xen height, Xen format, Xen type, Xen pixels) 2093 { 2094 #define H_glReadPixels "void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, \ 2095 GLenum type, GLvoid* pixels)" 2096 Xen_check_type(Xen_is_GLint(x), x, 1, "glReadPixels", "GLint"); 2097 Xen_check_type(Xen_is_GLint(y), y, 2, "glReadPixels", "GLint"); 2098 Xen_check_type(Xen_is_GLsizei(width), width, 3, "glReadPixels", "GLsizei"); 2099 Xen_check_type(Xen_is_GLsizei(height), height, 4, "glReadPixels", "GLsizei"); 2100 Xen_check_type(Xen_is_GLenum(format), format, 5, "glReadPixels", "GLenum"); 2101 Xen_check_type(Xen_is_GLenum(type), type, 6, "glReadPixels", "GLenum"); 2102 Xen_check_type(Xen_is_GLvoid_(pixels), pixels, 7, "glReadPixels", "GLvoid*"); 2103 glReadPixels(Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height), Xen_to_C_GLenum(format), 2104 Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(pixels)); 2105 return(Xen_false); 2106 } 2107 2108 static Xen gxg_glDrawPixels(Xen width, Xen height, Xen format, Xen type, Xen pixels) 2109 { 2110 #define H_glDrawPixels "void glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, \ 2111 GLvoid* pixels)" 2112 Xen_check_type(Xen_is_GLsizei(width), width, 1, "glDrawPixels", "GLsizei"); 2113 Xen_check_type(Xen_is_GLsizei(height), height, 2, "glDrawPixels", "GLsizei"); 2114 Xen_check_type(Xen_is_GLenum(format), format, 3, "glDrawPixels", "GLenum"); 2115 Xen_check_type(Xen_is_GLenum(type), type, 4, "glDrawPixels", "GLenum"); 2116 Xen_check_type(Xen_is_GLvoid_(pixels), pixels, 5, "glDrawPixels", "GLvoid*"); 2117 glDrawPixels(Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height), Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(pixels)); 2118 return(Xen_false); 2119 } 2120 2121 static Xen gxg_glCopyPixels(Xen x, Xen y, Xen width, Xen height, Xen type) 2122 { 2123 #define H_glCopyPixels "void glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)" 2124 Xen_check_type(Xen_is_GLint(x), x, 1, "glCopyPixels", "GLint"); 2125 Xen_check_type(Xen_is_GLint(y), y, 2, "glCopyPixels", "GLint"); 2126 Xen_check_type(Xen_is_GLsizei(width), width, 3, "glCopyPixels", "GLsizei"); 2127 Xen_check_type(Xen_is_GLsizei(height), height, 4, "glCopyPixels", "GLsizei"); 2128 Xen_check_type(Xen_is_GLenum(type), type, 5, "glCopyPixels", "GLenum"); 2129 glCopyPixels(Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height), Xen_to_C_GLenum(type)); 2130 return(Xen_false); 2131 } 2132 2133 static Xen gxg_glStencilFunc(Xen func, Xen ref, Xen mask) 2134 { 2135 #define H_glStencilFunc "void glStencilFunc(GLenum func, GLint ref, GLuint mask)" 2136 Xen_check_type(Xen_is_GLenum(func), func, 1, "glStencilFunc", "GLenum"); 2137 Xen_check_type(Xen_is_GLint(ref), ref, 2, "glStencilFunc", "GLint"); 2138 Xen_check_type(Xen_is_GLuint(mask), mask, 3, "glStencilFunc", "GLuint"); 2139 glStencilFunc(Xen_to_C_GLenum(func), Xen_to_C_GLint(ref), Xen_to_C_GLuint(mask)); 2140 return(Xen_false); 2141 } 2142 2143 static Xen gxg_glStencilMask(Xen mask) 2144 { 2145 #define H_glStencilMask "void glStencilMask(GLuint mask)" 2146 Xen_check_type(Xen_is_GLuint(mask), mask, 1, "glStencilMask", "GLuint"); 2147 glStencilMask(Xen_to_C_GLuint(mask)); 2148 return(Xen_false); 2149 } 2150 2151 static Xen gxg_glStencilOp(Xen fail, Xen zfail, Xen zpass) 2152 { 2153 #define H_glStencilOp "void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)" 2154 Xen_check_type(Xen_is_GLenum(fail), fail, 1, "glStencilOp", "GLenum"); 2155 Xen_check_type(Xen_is_GLenum(zfail), zfail, 2, "glStencilOp", "GLenum"); 2156 Xen_check_type(Xen_is_GLenum(zpass), zpass, 3, "glStencilOp", "GLenum"); 2157 glStencilOp(Xen_to_C_GLenum(fail), Xen_to_C_GLenum(zfail), Xen_to_C_GLenum(zpass)); 2158 return(Xen_false); 2159 } 2160 2161 static Xen gxg_glClearStencil(Xen s) 2162 { 2163 #define H_glClearStencil "void glClearStencil(GLint s)" 2164 Xen_check_type(Xen_is_GLint(s), s, 1, "glClearStencil", "GLint"); 2165 glClearStencil(Xen_to_C_GLint(s)); 2166 return(Xen_false); 2167 } 2168 2169 static Xen gxg_glTexGend(Xen coord, Xen pname, Xen param) 2170 { 2171 #define H_glTexGend "void glTexGend(GLenum coord, GLenum pname, GLdouble param)" 2172 Xen_check_type(Xen_is_GLenum(coord), coord, 1, "glTexGend", "GLenum"); 2173 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glTexGend", "GLenum"); 2174 Xen_check_type(Xen_is_GLdouble(param), param, 3, "glTexGend", "GLdouble"); 2175 glTexGend(Xen_to_C_GLenum(coord), Xen_to_C_GLenum(pname), Xen_to_C_GLdouble(param)); 2176 return(Xen_false); 2177 } 2178 2179 static Xen gxg_glTexGenf(Xen coord, Xen pname, Xen param) 2180 { 2181 #define H_glTexGenf "void glTexGenf(GLenum coord, GLenum pname, GLfloat param)" 2182 Xen_check_type(Xen_is_GLenum(coord), coord, 1, "glTexGenf", "GLenum"); 2183 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glTexGenf", "GLenum"); 2184 Xen_check_type(Xen_is_GLfloat(param), param, 3, "glTexGenf", "GLfloat"); 2185 glTexGenf(Xen_to_C_GLenum(coord), Xen_to_C_GLenum(pname), Xen_to_C_GLfloat(param)); 2186 return(Xen_false); 2187 } 2188 2189 static Xen gxg_glTexGeni(Xen coord, Xen pname, Xen param) 2190 { 2191 #define H_glTexGeni "void glTexGeni(GLenum coord, GLenum pname, GLint param)" 2192 Xen_check_type(Xen_is_GLenum(coord), coord, 1, "glTexGeni", "GLenum"); 2193 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glTexGeni", "GLenum"); 2194 Xen_check_type(Xen_is_GLint(param), param, 3, "glTexGeni", "GLint"); 2195 glTexGeni(Xen_to_C_GLenum(coord), Xen_to_C_GLenum(pname), Xen_to_C_GLint(param)); 2196 return(Xen_false); 2197 } 2198 2199 static Xen gxg_glGetTexGendv(Xen coord, Xen pname, Xen params) 2200 { 2201 #define H_glGetTexGendv "void glGetTexGendv(GLenum coord, GLenum pname, GLdouble* [params])" 2202 GLdouble ref_params[1]; 2203 Xen_check_type(Xen_is_GLenum(coord), coord, 1, "glGetTexGendv", "GLenum"); 2204 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetTexGendv", "GLenum"); 2205 glGetTexGendv(Xen_to_C_GLenum(coord), Xen_to_C_GLenum(pname), ref_params); 2206 return(Xen_list_1(C_to_Xen_GLdouble(ref_params[0]))); 2207 } 2208 2209 static Xen gxg_glGetTexGenfv(Xen coord, Xen pname, Xen params) 2210 { 2211 #define H_glGetTexGenfv "void glGetTexGenfv(GLenum coord, GLenum pname, GLfloat* [params])" 2212 GLfloat ref_params[1]; 2213 Xen_check_type(Xen_is_GLenum(coord), coord, 1, "glGetTexGenfv", "GLenum"); 2214 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetTexGenfv", "GLenum"); 2215 glGetTexGenfv(Xen_to_C_GLenum(coord), Xen_to_C_GLenum(pname), ref_params); 2216 return(Xen_list_1(C_to_Xen_GLfloat(ref_params[0]))); 2217 } 2218 2219 static Xen gxg_glGetTexGeniv(Xen coord, Xen pname, Xen params) 2220 { 2221 #define H_glGetTexGeniv "void glGetTexGeniv(GLenum coord, GLenum pname, GLint* [params])" 2222 GLint ref_params[1]; 2223 Xen_check_type(Xen_is_GLenum(coord), coord, 1, "glGetTexGeniv", "GLenum"); 2224 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetTexGeniv", "GLenum"); 2225 glGetTexGeniv(Xen_to_C_GLenum(coord), Xen_to_C_GLenum(pname), ref_params); 2226 return(Xen_list_1(C_to_Xen_GLint(ref_params[0]))); 2227 } 2228 2229 static Xen gxg_glTexEnvf(Xen target, Xen pname, Xen param) 2230 { 2231 #define H_glTexEnvf "void glTexEnvf(GLenum target, GLenum pname, GLfloat param)" 2232 Xen_check_type(Xen_is_GLenum(target), target, 1, "glTexEnvf", "GLenum"); 2233 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glTexEnvf", "GLenum"); 2234 Xen_check_type(Xen_is_GLfloat(param), param, 3, "glTexEnvf", "GLfloat"); 2235 glTexEnvf(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), Xen_to_C_GLfloat(param)); 2236 return(Xen_false); 2237 } 2238 2239 static Xen gxg_glTexEnvi(Xen target, Xen pname, Xen param) 2240 { 2241 #define H_glTexEnvi "void glTexEnvi(GLenum target, GLenum pname, GLint param)" 2242 Xen_check_type(Xen_is_GLenum(target), target, 1, "glTexEnvi", "GLenum"); 2243 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glTexEnvi", "GLenum"); 2244 Xen_check_type(Xen_is_GLint(param), param, 3, "glTexEnvi", "GLint"); 2245 glTexEnvi(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), Xen_to_C_GLint(param)); 2246 return(Xen_false); 2247 } 2248 2249 static Xen gxg_glGetTexEnvfv(Xen target, Xen pname, Xen params) 2250 { 2251 #define H_glGetTexEnvfv "void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat* [params])" 2252 GLfloat ref_params[1]; 2253 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetTexEnvfv", "GLenum"); 2254 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetTexEnvfv", "GLenum"); 2255 glGetTexEnvfv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), ref_params); 2256 return(Xen_list_1(C_to_Xen_GLfloat(ref_params[0]))); 2257 } 2258 2259 static Xen gxg_glGetTexEnviv(Xen target, Xen pname, Xen params) 2260 { 2261 #define H_glGetTexEnviv "void glGetTexEnviv(GLenum target, GLenum pname, GLint* [params])" 2262 GLint ref_params[1]; 2263 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetTexEnviv", "GLenum"); 2264 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetTexEnviv", "GLenum"); 2265 glGetTexEnviv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), ref_params); 2266 return(Xen_list_1(C_to_Xen_GLint(ref_params[0]))); 2267 } 2268 2269 static Xen gxg_glTexParameterf(Xen target, Xen pname, Xen param) 2270 { 2271 #define H_glTexParameterf "void glTexParameterf(GLenum target, GLenum pname, GLfloat param)" 2272 Xen_check_type(Xen_is_GLenum(target), target, 1, "glTexParameterf", "GLenum"); 2273 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glTexParameterf", "GLenum"); 2274 Xen_check_type(Xen_is_GLfloat(param), param, 3, "glTexParameterf", "GLfloat"); 2275 glTexParameterf(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), Xen_to_C_GLfloat(param)); 2276 return(Xen_false); 2277 } 2278 2279 static Xen gxg_glTexParameteri(Xen target, Xen pname, Xen param) 2280 { 2281 #define H_glTexParameteri "void glTexParameteri(GLenum target, GLenum pname, GLint param)" 2282 Xen_check_type(Xen_is_GLenum(target), target, 1, "glTexParameteri", "GLenum"); 2283 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glTexParameteri", "GLenum"); 2284 Xen_check_type(Xen_is_GLint(param), param, 3, "glTexParameteri", "GLint"); 2285 glTexParameteri(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), Xen_to_C_GLint(param)); 2286 return(Xen_false); 2287 } 2288 2289 static Xen gxg_glGetTexParameterfv(Xen target, Xen pname, Xen params) 2290 { 2291 #define H_glGetTexParameterfv "void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* [params])" 2292 GLfloat ref_params[1]; 2293 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetTexParameterfv", "GLenum"); 2294 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetTexParameterfv", "GLenum"); 2295 glGetTexParameterfv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), ref_params); 2296 return(Xen_list_1(C_to_Xen_GLfloat(ref_params[0]))); 2297 } 2298 2299 static Xen gxg_glGetTexParameteriv(Xen target, Xen pname, Xen params) 2300 { 2301 #define H_glGetTexParameteriv "void glGetTexParameteriv(GLenum target, GLenum pname, GLint* [params])" 2302 GLint ref_params[1]; 2303 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetTexParameteriv", "GLenum"); 2304 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetTexParameteriv", "GLenum"); 2305 glGetTexParameteriv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), ref_params); 2306 return(Xen_list_1(C_to_Xen_GLint(ref_params[0]))); 2307 } 2308 2309 static Xen gxg_glGetTexLevelParameterfv(Xen target, Xen level, Xen pname, Xen params) 2310 { 2311 #define H_glGetTexLevelParameterfv "void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, \ 2312 GLfloat* [params])" 2313 GLfloat ref_params[1]; 2314 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetTexLevelParameterfv", "GLenum"); 2315 Xen_check_type(Xen_is_GLint(level), level, 2, "glGetTexLevelParameterfv", "GLint"); 2316 Xen_check_type(Xen_is_GLenum(pname), pname, 3, "glGetTexLevelParameterfv", "GLenum"); 2317 glGetTexLevelParameterfv(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLenum(pname), ref_params); 2318 return(Xen_list_1(C_to_Xen_GLfloat(ref_params[0]))); 2319 } 2320 2321 static Xen gxg_glGetTexLevelParameteriv(Xen target, Xen level, Xen pname, Xen params) 2322 { 2323 #define H_glGetTexLevelParameteriv "void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, \ 2324 GLint* [params])" 2325 GLint ref_params[1]; 2326 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetTexLevelParameteriv", "GLenum"); 2327 Xen_check_type(Xen_is_GLint(level), level, 2, "glGetTexLevelParameteriv", "GLint"); 2328 Xen_check_type(Xen_is_GLenum(pname), pname, 3, "glGetTexLevelParameteriv", "GLenum"); 2329 glGetTexLevelParameteriv(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLenum(pname), ref_params); 2330 return(Xen_list_1(C_to_Xen_GLint(ref_params[0]))); 2331 } 2332 2333 static Xen gxg_glTexImage1D(Xen arglist) 2334 { 2335 #define H_glTexImage1D "void glTexImage1D(GLenum target, GLint level, GLint internalFormat, GLsizei width, \ 2336 GLint border, GLenum format, GLenum type, GLvoid* pixels)" 2337 Xen target, level, internalFormat, width, border, format, type, pixels; 2338 target = Xen_list_ref(arglist, 0); 2339 level = Xen_list_ref(arglist, 1); 2340 internalFormat = Xen_list_ref(arglist, 2); 2341 width = Xen_list_ref(arglist, 3); 2342 border = Xen_list_ref(arglist, 4); 2343 format = Xen_list_ref(arglist, 5); 2344 type = Xen_list_ref(arglist, 6); 2345 pixels = Xen_list_ref(arglist, 7); 2346 Xen_check_type(Xen_is_GLenum(target), target, 1, "glTexImage1D", "GLenum"); 2347 Xen_check_type(Xen_is_GLint(level), level, 2, "glTexImage1D", "GLint"); 2348 Xen_check_type(Xen_is_GLint(internalFormat), internalFormat, 3, "glTexImage1D", "GLint"); 2349 Xen_check_type(Xen_is_GLsizei(width), width, 4, "glTexImage1D", "GLsizei"); 2350 Xen_check_type(Xen_is_GLint(border), border, 5, "glTexImage1D", "GLint"); 2351 Xen_check_type(Xen_is_GLenum(format), format, 6, "glTexImage1D", "GLenum"); 2352 Xen_check_type(Xen_is_GLenum(type), type, 7, "glTexImage1D", "GLenum"); 2353 Xen_check_type(Xen_is_GLvoid_(pixels), pixels, 8, "glTexImage1D", "GLvoid*"); 2354 glTexImage1D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLint(internalFormat), Xen_to_C_GLsizei(width), Xen_to_C_GLint(border), 2355 Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(pixels)); 2356 return(Xen_false); 2357 } 2358 2359 static Xen gxg_glTexImage2D(Xen arglist) 2360 { 2361 #define H_glTexImage2D "void glTexImage2D(GLenum target, GLint level, GLint internalFormat, GLsizei width, \ 2362 GLsizei height, GLint border, GLenum format, GLenum type, GLvoid* pixels)" 2363 Xen target, level, internalFormat, width, height, border, format, type, pixels; 2364 target = Xen_list_ref(arglist, 0); 2365 level = Xen_list_ref(arglist, 1); 2366 internalFormat = Xen_list_ref(arglist, 2); 2367 width = Xen_list_ref(arglist, 3); 2368 height = Xen_list_ref(arglist, 4); 2369 border = Xen_list_ref(arglist, 5); 2370 format = Xen_list_ref(arglist, 6); 2371 type = Xen_list_ref(arglist, 7); 2372 pixels = Xen_list_ref(arglist, 8); 2373 Xen_check_type(Xen_is_GLenum(target), target, 1, "glTexImage2D", "GLenum"); 2374 Xen_check_type(Xen_is_GLint(level), level, 2, "glTexImage2D", "GLint"); 2375 Xen_check_type(Xen_is_GLint(internalFormat), internalFormat, 3, "glTexImage2D", "GLint"); 2376 Xen_check_type(Xen_is_GLsizei(width), width, 4, "glTexImage2D", "GLsizei"); 2377 Xen_check_type(Xen_is_GLsizei(height), height, 5, "glTexImage2D", "GLsizei"); 2378 Xen_check_type(Xen_is_GLint(border), border, 6, "glTexImage2D", "GLint"); 2379 Xen_check_type(Xen_is_GLenum(format), format, 7, "glTexImage2D", "GLenum"); 2380 Xen_check_type(Xen_is_GLenum(type), type, 8, "glTexImage2D", "GLenum"); 2381 Xen_check_type(Xen_is_GLvoid_(pixels), pixels, 9, "glTexImage2D", "GLvoid*"); 2382 glTexImage2D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLint(internalFormat), Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height), 2383 Xen_to_C_GLint(border), Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(pixels)); 2384 return(Xen_false); 2385 } 2386 2387 static Xen gxg_glGenTextures(Xen n, Xen textures) 2388 { 2389 #define H_glGenTextures "void glGenTextures(GLsizei n, GLuint* textures)" 2390 Xen_check_type(Xen_is_GLsizei(n), n, 1, "glGenTextures", "GLsizei"); 2391 Xen_check_type(Xen_is_GLuint_(textures), textures, 2, "glGenTextures", "GLuint*"); 2392 glGenTextures(Xen_to_C_GLsizei(n), Xen_to_C_GLuint_(textures)); 2393 return(Xen_false); 2394 } 2395 2396 static Xen gxg_glDeleteTextures(Xen n, Xen textures) 2397 { 2398 #define H_glDeleteTextures "void glDeleteTextures(GLsizei n, GLuint* textures)" 2399 Xen_check_type(Xen_is_GLsizei(n), n, 1, "glDeleteTextures", "GLsizei"); 2400 Xen_check_type(Xen_is_GLuint_(textures), textures, 2, "glDeleteTextures", "GLuint*"); 2401 glDeleteTextures(Xen_to_C_GLsizei(n), Xen_to_C_GLuint_(textures)); 2402 return(Xen_false); 2403 } 2404 2405 static Xen gxg_glBindTexture(Xen target, Xen texture) 2406 { 2407 #define H_glBindTexture "void glBindTexture(GLenum target, GLuint texture)" 2408 Xen_check_type(Xen_is_GLenum(target), target, 1, "glBindTexture", "GLenum"); 2409 Xen_check_type(Xen_is_GLuint(texture), texture, 2, "glBindTexture", "GLuint"); 2410 glBindTexture(Xen_to_C_GLenum(target), Xen_to_C_GLuint(texture)); 2411 return(Xen_false); 2412 } 2413 2414 static Xen gxg_glAreTexturesResident(Xen n, Xen textures, Xen residences) 2415 { 2416 #define H_glAreTexturesResident "GLboolean glAreTexturesResident(GLsizei n, GLuint* textures, GLboolean* residences)" 2417 Xen_check_type(Xen_is_GLsizei(n), n, 1, "glAreTexturesResident", "GLsizei"); 2418 Xen_check_type(Xen_is_GLuint_(textures), textures, 2, "glAreTexturesResident", "GLuint*"); 2419 Xen_check_type(Xen_is_GLboolean_(residences), residences, 3, "glAreTexturesResident", "GLboolean*"); 2420 return(C_to_Xen_GLboolean(glAreTexturesResident(Xen_to_C_GLsizei(n), Xen_to_C_GLuint_(textures), Xen_to_C_GLboolean_(residences)))); 2421 } 2422 2423 static Xen gxg_glIsTexture(Xen texture) 2424 { 2425 #define H_glIsTexture "GLboolean glIsTexture(GLuint texture)" 2426 Xen_check_type(Xen_is_GLuint(texture), texture, 1, "glIsTexture", "GLuint"); 2427 return(C_to_Xen_GLboolean(glIsTexture(Xen_to_C_GLuint(texture)))); 2428 } 2429 2430 static Xen gxg_glTexSubImage1D(Xen target, Xen level, Xen xoffset, Xen width, Xen format, Xen type, Xen pixels) 2431 { 2432 #define H_glTexSubImage1D "void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, \ 2433 GLenum format, GLenum type, GLvoid* pixels)" 2434 Xen_check_type(Xen_is_GLenum(target), target, 1, "glTexSubImage1D", "GLenum"); 2435 Xen_check_type(Xen_is_GLint(level), level, 2, "glTexSubImage1D", "GLint"); 2436 Xen_check_type(Xen_is_GLint(xoffset), xoffset, 3, "glTexSubImage1D", "GLint"); 2437 Xen_check_type(Xen_is_GLsizei(width), width, 4, "glTexSubImage1D", "GLsizei"); 2438 Xen_check_type(Xen_is_GLenum(format), format, 5, "glTexSubImage1D", "GLenum"); 2439 Xen_check_type(Xen_is_GLenum(type), type, 6, "glTexSubImage1D", "GLenum"); 2440 Xen_check_type(Xen_is_GLvoid_(pixels), pixels, 7, "glTexSubImage1D", "GLvoid*"); 2441 glTexSubImage1D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLint(xoffset), Xen_to_C_GLsizei(width), Xen_to_C_GLenum(format), 2442 Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(pixels)); 2443 return(Xen_false); 2444 } 2445 2446 static Xen gxg_glTexSubImage2D(Xen arglist) 2447 { 2448 #define H_glTexSubImage2D "void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, \ 2449 GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)" 2450 Xen target, level, xoffset, yoffset, width, height, format, type, pixels; 2451 target = Xen_list_ref(arglist, 0); 2452 level = Xen_list_ref(arglist, 1); 2453 xoffset = Xen_list_ref(arglist, 2); 2454 yoffset = Xen_list_ref(arglist, 3); 2455 width = Xen_list_ref(arglist, 4); 2456 height = Xen_list_ref(arglist, 5); 2457 format = Xen_list_ref(arglist, 6); 2458 type = Xen_list_ref(arglist, 7); 2459 pixels = Xen_list_ref(arglist, 8); 2460 Xen_check_type(Xen_is_GLenum(target), target, 1, "glTexSubImage2D", "GLenum"); 2461 Xen_check_type(Xen_is_GLint(level), level, 2, "glTexSubImage2D", "GLint"); 2462 Xen_check_type(Xen_is_GLint(xoffset), xoffset, 3, "glTexSubImage2D", "GLint"); 2463 Xen_check_type(Xen_is_GLint(yoffset), yoffset, 4, "glTexSubImage2D", "GLint"); 2464 Xen_check_type(Xen_is_GLsizei(width), width, 5, "glTexSubImage2D", "GLsizei"); 2465 Xen_check_type(Xen_is_GLsizei(height), height, 6, "glTexSubImage2D", "GLsizei"); 2466 Xen_check_type(Xen_is_GLenum(format), format, 7, "glTexSubImage2D", "GLenum"); 2467 Xen_check_type(Xen_is_GLenum(type), type, 8, "glTexSubImage2D", "GLenum"); 2468 Xen_check_type(Xen_is_GLvoid_(pixels), pixels, 9, "glTexSubImage2D", "GLvoid*"); 2469 glTexSubImage2D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLint(xoffset), Xen_to_C_GLint(yoffset), Xen_to_C_GLsizei(width), 2470 Xen_to_C_GLsizei(height), Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(pixels)); 2471 return(Xen_false); 2472 } 2473 2474 static Xen gxg_glCopyTexImage1D(Xen target, Xen level, Xen internalformat, Xen x, Xen y, Xen width, Xen border) 2475 { 2476 #define H_glCopyTexImage1D "void glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, \ 2477 GLint x, GLint y, GLsizei width, GLint border)" 2478 Xen_check_type(Xen_is_GLenum(target), target, 1, "glCopyTexImage1D", "GLenum"); 2479 Xen_check_type(Xen_is_GLint(level), level, 2, "glCopyTexImage1D", "GLint"); 2480 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 3, "glCopyTexImage1D", "GLenum"); 2481 Xen_check_type(Xen_is_GLint(x), x, 4, "glCopyTexImage1D", "GLint"); 2482 Xen_check_type(Xen_is_GLint(y), y, 5, "glCopyTexImage1D", "GLint"); 2483 Xen_check_type(Xen_is_GLsizei(width), width, 6, "glCopyTexImage1D", "GLsizei"); 2484 Xen_check_type(Xen_is_GLint(border), border, 7, "glCopyTexImage1D", "GLint"); 2485 glCopyTexImage1D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLenum(internalformat), Xen_to_C_GLint(x), Xen_to_C_GLint(y), 2486 Xen_to_C_GLsizei(width), Xen_to_C_GLint(border)); 2487 return(Xen_false); 2488 } 2489 2490 static Xen gxg_glCopyTexImage2D(Xen arglist) 2491 { 2492 #define H_glCopyTexImage2D "void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, \ 2493 GLint x, GLint y, GLsizei width, GLsizei height, GLint border)" 2494 Xen target, level, internalformat, x, y, width, height, border; 2495 target = Xen_list_ref(arglist, 0); 2496 level = Xen_list_ref(arglist, 1); 2497 internalformat = Xen_list_ref(arglist, 2); 2498 x = Xen_list_ref(arglist, 3); 2499 y = Xen_list_ref(arglist, 4); 2500 width = Xen_list_ref(arglist, 5); 2501 height = Xen_list_ref(arglist, 6); 2502 border = Xen_list_ref(arglist, 7); 2503 Xen_check_type(Xen_is_GLenum(target), target, 1, "glCopyTexImage2D", "GLenum"); 2504 Xen_check_type(Xen_is_GLint(level), level, 2, "glCopyTexImage2D", "GLint"); 2505 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 3, "glCopyTexImage2D", "GLenum"); 2506 Xen_check_type(Xen_is_GLint(x), x, 4, "glCopyTexImage2D", "GLint"); 2507 Xen_check_type(Xen_is_GLint(y), y, 5, "glCopyTexImage2D", "GLint"); 2508 Xen_check_type(Xen_is_GLsizei(width), width, 6, "glCopyTexImage2D", "GLsizei"); 2509 Xen_check_type(Xen_is_GLsizei(height), height, 7, "glCopyTexImage2D", "GLsizei"); 2510 Xen_check_type(Xen_is_GLint(border), border, 8, "glCopyTexImage2D", "GLint"); 2511 glCopyTexImage2D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLenum(internalformat), Xen_to_C_GLint(x), Xen_to_C_GLint(y), 2512 Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height), Xen_to_C_GLint(border)); 2513 return(Xen_false); 2514 } 2515 2516 static Xen gxg_glCopyTexSubImage1D(Xen target, Xen level, Xen xoffset, Xen x, Xen y, Xen width) 2517 { 2518 #define H_glCopyTexSubImage1D "void glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, \ 2519 GLint x, GLint y, GLsizei width)" 2520 Xen_check_type(Xen_is_GLenum(target), target, 1, "glCopyTexSubImage1D", "GLenum"); 2521 Xen_check_type(Xen_is_GLint(level), level, 2, "glCopyTexSubImage1D", "GLint"); 2522 Xen_check_type(Xen_is_GLint(xoffset), xoffset, 3, "glCopyTexSubImage1D", "GLint"); 2523 Xen_check_type(Xen_is_GLint(x), x, 4, "glCopyTexSubImage1D", "GLint"); 2524 Xen_check_type(Xen_is_GLint(y), y, 5, "glCopyTexSubImage1D", "GLint"); 2525 Xen_check_type(Xen_is_GLsizei(width), width, 6, "glCopyTexSubImage1D", "GLsizei"); 2526 glCopyTexSubImage1D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLint(xoffset), Xen_to_C_GLint(x), Xen_to_C_GLint(y), 2527 Xen_to_C_GLsizei(width)); 2528 return(Xen_false); 2529 } 2530 2531 static Xen gxg_glCopyTexSubImage2D(Xen arglist) 2532 { 2533 #define H_glCopyTexSubImage2D "void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, \ 2534 GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)" 2535 Xen target, level, xoffset, yoffset, x, y, width, height; 2536 target = Xen_list_ref(arglist, 0); 2537 level = Xen_list_ref(arglist, 1); 2538 xoffset = Xen_list_ref(arglist, 2); 2539 yoffset = Xen_list_ref(arglist, 3); 2540 x = Xen_list_ref(arglist, 4); 2541 y = Xen_list_ref(arglist, 5); 2542 width = Xen_list_ref(arglist, 6); 2543 height = Xen_list_ref(arglist, 7); 2544 Xen_check_type(Xen_is_GLenum(target), target, 1, "glCopyTexSubImage2D", "GLenum"); 2545 Xen_check_type(Xen_is_GLint(level), level, 2, "glCopyTexSubImage2D", "GLint"); 2546 Xen_check_type(Xen_is_GLint(xoffset), xoffset, 3, "glCopyTexSubImage2D", "GLint"); 2547 Xen_check_type(Xen_is_GLint(yoffset), yoffset, 4, "glCopyTexSubImage2D", "GLint"); 2548 Xen_check_type(Xen_is_GLint(x), x, 5, "glCopyTexSubImage2D", "GLint"); 2549 Xen_check_type(Xen_is_GLint(y), y, 6, "glCopyTexSubImage2D", "GLint"); 2550 Xen_check_type(Xen_is_GLsizei(width), width, 7, "glCopyTexSubImage2D", "GLsizei"); 2551 Xen_check_type(Xen_is_GLsizei(height), height, 8, "glCopyTexSubImage2D", "GLsizei"); 2552 glCopyTexSubImage2D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLint(xoffset), Xen_to_C_GLint(yoffset), Xen_to_C_GLint(x), 2553 Xen_to_C_GLint(y), Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height)); 2554 return(Xen_false); 2555 } 2556 2557 static Xen gxg_glMap1d(Xen target, Xen u1, Xen u2, Xen stride, Xen order, Xen points) 2558 { 2559 #define H_glMap1d "void glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, \ 2560 GLdouble* points)" 2561 Xen_check_type(Xen_is_GLenum(target), target, 1, "glMap1d", "GLenum"); 2562 Xen_check_type(Xen_is_GLdouble(u1), u1, 2, "glMap1d", "GLdouble"); 2563 Xen_check_type(Xen_is_GLdouble(u2), u2, 3, "glMap1d", "GLdouble"); 2564 Xen_check_type(Xen_is_GLint(stride), stride, 4, "glMap1d", "GLint"); 2565 Xen_check_type(Xen_is_GLint(order), order, 5, "glMap1d", "GLint"); 2566 Xen_check_type(Xen_is_GLdouble_(points), points, 6, "glMap1d", "GLdouble*"); 2567 glMap1d(Xen_to_C_GLenum(target), Xen_to_C_GLdouble(u1), Xen_to_C_GLdouble(u2), Xen_to_C_GLint(stride), Xen_to_C_GLint(order), 2568 Xen_to_C_GLdouble_(points)); 2569 return(Xen_false); 2570 } 2571 2572 static Xen gxg_glMap1f(Xen target, Xen u1, Xen u2, Xen stride, Xen order, Xen points) 2573 { 2574 #define H_glMap1f "void glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat* points)" 2575 Xen_check_type(Xen_is_GLenum(target), target, 1, "glMap1f", "GLenum"); 2576 Xen_check_type(Xen_is_GLfloat(u1), u1, 2, "glMap1f", "GLfloat"); 2577 Xen_check_type(Xen_is_GLfloat(u2), u2, 3, "glMap1f", "GLfloat"); 2578 Xen_check_type(Xen_is_GLint(stride), stride, 4, "glMap1f", "GLint"); 2579 Xen_check_type(Xen_is_GLint(order), order, 5, "glMap1f", "GLint"); 2580 Xen_check_type(Xen_is_GLfloat_(points), points, 6, "glMap1f", "GLfloat*"); 2581 glMap1f(Xen_to_C_GLenum(target), Xen_to_C_GLfloat(u1), Xen_to_C_GLfloat(u2), Xen_to_C_GLint(stride), Xen_to_C_GLint(order), 2582 Xen_to_C_GLfloat_(points)); 2583 return(Xen_false); 2584 } 2585 2586 static Xen gxg_glMap2d(Xen arglist) 2587 { 2588 #define H_glMap2d "void glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, \ 2589 GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble* points)" 2590 Xen target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points; 2591 target = Xen_list_ref(arglist, 0); 2592 u1 = Xen_list_ref(arglist, 1); 2593 u2 = Xen_list_ref(arglist, 2); 2594 ustride = Xen_list_ref(arglist, 3); 2595 uorder = Xen_list_ref(arglist, 4); 2596 v1 = Xen_list_ref(arglist, 5); 2597 v2 = Xen_list_ref(arglist, 6); 2598 vstride = Xen_list_ref(arglist, 7); 2599 vorder = Xen_list_ref(arglist, 8); 2600 points = Xen_list_ref(arglist, 9); 2601 Xen_check_type(Xen_is_GLenum(target), target, 1, "glMap2d", "GLenum"); 2602 Xen_check_type(Xen_is_GLdouble(u1), u1, 2, "glMap2d", "GLdouble"); 2603 Xen_check_type(Xen_is_GLdouble(u2), u2, 3, "glMap2d", "GLdouble"); 2604 Xen_check_type(Xen_is_GLint(ustride), ustride, 4, "glMap2d", "GLint"); 2605 Xen_check_type(Xen_is_GLint(uorder), uorder, 5, "glMap2d", "GLint"); 2606 Xen_check_type(Xen_is_GLdouble(v1), v1, 6, "glMap2d", "GLdouble"); 2607 Xen_check_type(Xen_is_GLdouble(v2), v2, 7, "glMap2d", "GLdouble"); 2608 Xen_check_type(Xen_is_GLint(vstride), vstride, 8, "glMap2d", "GLint"); 2609 Xen_check_type(Xen_is_GLint(vorder), vorder, 9, "glMap2d", "GLint"); 2610 Xen_check_type(Xen_is_GLdouble_(points), points, 10, "glMap2d", "GLdouble*"); 2611 glMap2d(Xen_to_C_GLenum(target), Xen_to_C_GLdouble(u1), Xen_to_C_GLdouble(u2), Xen_to_C_GLint(ustride), Xen_to_C_GLint(uorder), 2612 Xen_to_C_GLdouble(v1), Xen_to_C_GLdouble(v2), Xen_to_C_GLint(vstride), Xen_to_C_GLint(vorder), Xen_to_C_GLdouble_(points)); 2613 return(Xen_false); 2614 } 2615 2616 static Xen gxg_glMap2f(Xen arglist) 2617 { 2618 #define H_glMap2f "void glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, \ 2619 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat* points)" 2620 Xen target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points; 2621 target = Xen_list_ref(arglist, 0); 2622 u1 = Xen_list_ref(arglist, 1); 2623 u2 = Xen_list_ref(arglist, 2); 2624 ustride = Xen_list_ref(arglist, 3); 2625 uorder = Xen_list_ref(arglist, 4); 2626 v1 = Xen_list_ref(arglist, 5); 2627 v2 = Xen_list_ref(arglist, 6); 2628 vstride = Xen_list_ref(arglist, 7); 2629 vorder = Xen_list_ref(arglist, 8); 2630 points = Xen_list_ref(arglist, 9); 2631 Xen_check_type(Xen_is_GLenum(target), target, 1, "glMap2f", "GLenum"); 2632 Xen_check_type(Xen_is_GLfloat(u1), u1, 2, "glMap2f", "GLfloat"); 2633 Xen_check_type(Xen_is_GLfloat(u2), u2, 3, "glMap2f", "GLfloat"); 2634 Xen_check_type(Xen_is_GLint(ustride), ustride, 4, "glMap2f", "GLint"); 2635 Xen_check_type(Xen_is_GLint(uorder), uorder, 5, "glMap2f", "GLint"); 2636 Xen_check_type(Xen_is_GLfloat(v1), v1, 6, "glMap2f", "GLfloat"); 2637 Xen_check_type(Xen_is_GLfloat(v2), v2, 7, "glMap2f", "GLfloat"); 2638 Xen_check_type(Xen_is_GLint(vstride), vstride, 8, "glMap2f", "GLint"); 2639 Xen_check_type(Xen_is_GLint(vorder), vorder, 9, "glMap2f", "GLint"); 2640 Xen_check_type(Xen_is_GLfloat_(points), points, 10, "glMap2f", "GLfloat*"); 2641 glMap2f(Xen_to_C_GLenum(target), Xen_to_C_GLfloat(u1), Xen_to_C_GLfloat(u2), Xen_to_C_GLint(ustride), Xen_to_C_GLint(uorder), 2642 Xen_to_C_GLfloat(v1), Xen_to_C_GLfloat(v2), Xen_to_C_GLint(vstride), Xen_to_C_GLint(vorder), Xen_to_C_GLfloat_(points)); 2643 return(Xen_false); 2644 } 2645 2646 static Xen gxg_glGetMapdv(Xen target, Xen query, Xen v) 2647 { 2648 #define H_glGetMapdv "void glGetMapdv(GLenum target, GLenum query, GLdouble* [v])" 2649 GLdouble ref_v[1]; 2650 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetMapdv", "GLenum"); 2651 Xen_check_type(Xen_is_GLenum(query), query, 2, "glGetMapdv", "GLenum"); 2652 glGetMapdv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(query), ref_v); 2653 return(Xen_list_1(C_to_Xen_GLdouble(ref_v[0]))); 2654 } 2655 2656 static Xen gxg_glGetMapfv(Xen target, Xen query, Xen v) 2657 { 2658 #define H_glGetMapfv "void glGetMapfv(GLenum target, GLenum query, GLfloat* [v])" 2659 GLfloat ref_v[1]; 2660 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetMapfv", "GLenum"); 2661 Xen_check_type(Xen_is_GLenum(query), query, 2, "glGetMapfv", "GLenum"); 2662 glGetMapfv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(query), ref_v); 2663 return(Xen_list_1(C_to_Xen_GLfloat(ref_v[0]))); 2664 } 2665 2666 static Xen gxg_glGetMapiv(Xen target, Xen query, Xen v) 2667 { 2668 #define H_glGetMapiv "void glGetMapiv(GLenum target, GLenum query, GLint* [v])" 2669 GLint ref_v[1]; 2670 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetMapiv", "GLenum"); 2671 Xen_check_type(Xen_is_GLenum(query), query, 2, "glGetMapiv", "GLenum"); 2672 glGetMapiv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(query), ref_v); 2673 return(Xen_list_1(C_to_Xen_GLint(ref_v[0]))); 2674 } 2675 2676 static Xen gxg_glEvalCoord1d(Xen u) 2677 { 2678 #define H_glEvalCoord1d "void glEvalCoord1d(GLdouble u)" 2679 Xen_check_type(Xen_is_GLdouble(u), u, 1, "glEvalCoord1d", "GLdouble"); 2680 glEvalCoord1d(Xen_to_C_GLdouble(u)); 2681 return(Xen_false); 2682 } 2683 2684 static Xen gxg_glEvalCoord1f(Xen u) 2685 { 2686 #define H_glEvalCoord1f "void glEvalCoord1f(GLfloat u)" 2687 Xen_check_type(Xen_is_GLfloat(u), u, 1, "glEvalCoord1f", "GLfloat"); 2688 glEvalCoord1f(Xen_to_C_GLfloat(u)); 2689 return(Xen_false); 2690 } 2691 2692 static Xen gxg_glEvalCoord2d(Xen u, Xen v) 2693 { 2694 #define H_glEvalCoord2d "void glEvalCoord2d(GLdouble u, GLdouble v)" 2695 Xen_check_type(Xen_is_GLdouble(u), u, 1, "glEvalCoord2d", "GLdouble"); 2696 Xen_check_type(Xen_is_GLdouble(v), v, 2, "glEvalCoord2d", "GLdouble"); 2697 glEvalCoord2d(Xen_to_C_GLdouble(u), Xen_to_C_GLdouble(v)); 2698 return(Xen_false); 2699 } 2700 2701 static Xen gxg_glEvalCoord2f(Xen u, Xen v) 2702 { 2703 #define H_glEvalCoord2f "void glEvalCoord2f(GLfloat u, GLfloat v)" 2704 Xen_check_type(Xen_is_GLfloat(u), u, 1, "glEvalCoord2f", "GLfloat"); 2705 Xen_check_type(Xen_is_GLfloat(v), v, 2, "glEvalCoord2f", "GLfloat"); 2706 glEvalCoord2f(Xen_to_C_GLfloat(u), Xen_to_C_GLfloat(v)); 2707 return(Xen_false); 2708 } 2709 2710 static Xen gxg_glMapGrid1d(Xen un, Xen u1, Xen u2) 2711 { 2712 #define H_glMapGrid1d "void glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)" 2713 Xen_check_type(Xen_is_GLint(un), un, 1, "glMapGrid1d", "GLint"); 2714 Xen_check_type(Xen_is_GLdouble(u1), u1, 2, "glMapGrid1d", "GLdouble"); 2715 Xen_check_type(Xen_is_GLdouble(u2), u2, 3, "glMapGrid1d", "GLdouble"); 2716 glMapGrid1d(Xen_to_C_GLint(un), Xen_to_C_GLdouble(u1), Xen_to_C_GLdouble(u2)); 2717 return(Xen_false); 2718 } 2719 2720 static Xen gxg_glMapGrid1f(Xen un, Xen u1, Xen u2) 2721 { 2722 #define H_glMapGrid1f "void glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)" 2723 Xen_check_type(Xen_is_GLint(un), un, 1, "glMapGrid1f", "GLint"); 2724 Xen_check_type(Xen_is_GLfloat(u1), u1, 2, "glMapGrid1f", "GLfloat"); 2725 Xen_check_type(Xen_is_GLfloat(u2), u2, 3, "glMapGrid1f", "GLfloat"); 2726 glMapGrid1f(Xen_to_C_GLint(un), Xen_to_C_GLfloat(u1), Xen_to_C_GLfloat(u2)); 2727 return(Xen_false); 2728 } 2729 2730 static Xen gxg_glMapGrid2d(Xen un, Xen u1, Xen u2, Xen vn, Xen v1, Xen v2) 2731 { 2732 #define H_glMapGrid2d "void glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, \ 2733 GLdouble v2)" 2734 Xen_check_type(Xen_is_GLint(un), un, 1, "glMapGrid2d", "GLint"); 2735 Xen_check_type(Xen_is_GLdouble(u1), u1, 2, "glMapGrid2d", "GLdouble"); 2736 Xen_check_type(Xen_is_GLdouble(u2), u2, 3, "glMapGrid2d", "GLdouble"); 2737 Xen_check_type(Xen_is_GLint(vn), vn, 4, "glMapGrid2d", "GLint"); 2738 Xen_check_type(Xen_is_GLdouble(v1), v1, 5, "glMapGrid2d", "GLdouble"); 2739 Xen_check_type(Xen_is_GLdouble(v2), v2, 6, "glMapGrid2d", "GLdouble"); 2740 glMapGrid2d(Xen_to_C_GLint(un), Xen_to_C_GLdouble(u1), Xen_to_C_GLdouble(u2), Xen_to_C_GLint(vn), Xen_to_C_GLdouble(v1), 2741 Xen_to_C_GLdouble(v2)); 2742 return(Xen_false); 2743 } 2744 2745 static Xen gxg_glMapGrid2f(Xen un, Xen u1, Xen u2, Xen vn, Xen v1, Xen v2) 2746 { 2747 #define H_glMapGrid2f "void glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)" 2748 Xen_check_type(Xen_is_GLint(un), un, 1, "glMapGrid2f", "GLint"); 2749 Xen_check_type(Xen_is_GLfloat(u1), u1, 2, "glMapGrid2f", "GLfloat"); 2750 Xen_check_type(Xen_is_GLfloat(u2), u2, 3, "glMapGrid2f", "GLfloat"); 2751 Xen_check_type(Xen_is_GLint(vn), vn, 4, "glMapGrid2f", "GLint"); 2752 Xen_check_type(Xen_is_GLfloat(v1), v1, 5, "glMapGrid2f", "GLfloat"); 2753 Xen_check_type(Xen_is_GLfloat(v2), v2, 6, "glMapGrid2f", "GLfloat"); 2754 glMapGrid2f(Xen_to_C_GLint(un), Xen_to_C_GLfloat(u1), Xen_to_C_GLfloat(u2), Xen_to_C_GLint(vn), Xen_to_C_GLfloat(v1), Xen_to_C_GLfloat(v2)); 2755 return(Xen_false); 2756 } 2757 2758 static Xen gxg_glEvalPoint1(Xen i) 2759 { 2760 #define H_glEvalPoint1 "void glEvalPoint1(GLint i)" 2761 Xen_check_type(Xen_is_GLint(i), i, 1, "glEvalPoint1", "GLint"); 2762 glEvalPoint1(Xen_to_C_GLint(i)); 2763 return(Xen_false); 2764 } 2765 2766 static Xen gxg_glEvalPoint2(Xen i, Xen j) 2767 { 2768 #define H_glEvalPoint2 "void glEvalPoint2(GLint i, GLint j)" 2769 Xen_check_type(Xen_is_GLint(i), i, 1, "glEvalPoint2", "GLint"); 2770 Xen_check_type(Xen_is_GLint(j), j, 2, "glEvalPoint2", "GLint"); 2771 glEvalPoint2(Xen_to_C_GLint(i), Xen_to_C_GLint(j)); 2772 return(Xen_false); 2773 } 2774 2775 static Xen gxg_glEvalMesh1(Xen mode, Xen i1, Xen i2) 2776 { 2777 #define H_glEvalMesh1 "void glEvalMesh1(GLenum mode, GLint i1, GLint i2)" 2778 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glEvalMesh1", "GLenum"); 2779 Xen_check_type(Xen_is_GLint(i1), i1, 2, "glEvalMesh1", "GLint"); 2780 Xen_check_type(Xen_is_GLint(i2), i2, 3, "glEvalMesh1", "GLint"); 2781 glEvalMesh1(Xen_to_C_GLenum(mode), Xen_to_C_GLint(i1), Xen_to_C_GLint(i2)); 2782 return(Xen_false); 2783 } 2784 2785 static Xen gxg_glEvalMesh2(Xen mode, Xen i1, Xen i2, Xen j1, Xen j2) 2786 { 2787 #define H_glEvalMesh2 "void glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)" 2788 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glEvalMesh2", "GLenum"); 2789 Xen_check_type(Xen_is_GLint(i1), i1, 2, "glEvalMesh2", "GLint"); 2790 Xen_check_type(Xen_is_GLint(i2), i2, 3, "glEvalMesh2", "GLint"); 2791 Xen_check_type(Xen_is_GLint(j1), j1, 4, "glEvalMesh2", "GLint"); 2792 Xen_check_type(Xen_is_GLint(j2), j2, 5, "glEvalMesh2", "GLint"); 2793 glEvalMesh2(Xen_to_C_GLenum(mode), Xen_to_C_GLint(i1), Xen_to_C_GLint(i2), Xen_to_C_GLint(j1), Xen_to_C_GLint(j2)); 2794 return(Xen_false); 2795 } 2796 2797 static Xen gxg_glFogf(Xen pname, Xen param) 2798 { 2799 #define H_glFogf "void glFogf(GLenum pname, GLfloat param)" 2800 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glFogf", "GLenum"); 2801 Xen_check_type(Xen_is_GLfloat(param), param, 2, "glFogf", "GLfloat"); 2802 glFogf(Xen_to_C_GLenum(pname), Xen_to_C_GLfloat(param)); 2803 return(Xen_false); 2804 } 2805 2806 static Xen gxg_glFogi(Xen pname, Xen param) 2807 { 2808 #define H_glFogi "void glFogi(GLenum pname, GLint param)" 2809 Xen_check_type(Xen_is_GLenum(pname), pname, 1, "glFogi", "GLenum"); 2810 Xen_check_type(Xen_is_GLint(param), param, 2, "glFogi", "GLint"); 2811 glFogi(Xen_to_C_GLenum(pname), Xen_to_C_GLint(param)); 2812 return(Xen_false); 2813 } 2814 2815 static Xen gxg_glFeedbackBuffer(Xen size, Xen type, Xen buffer) 2816 { 2817 #define H_glFeedbackBuffer "void glFeedbackBuffer(GLsizei size, GLenum type, GLfloat* buffer)" 2818 Xen_check_type(Xen_is_GLsizei(size), size, 1, "glFeedbackBuffer", "GLsizei"); 2819 Xen_check_type(Xen_is_GLenum(type), type, 2, "glFeedbackBuffer", "GLenum"); 2820 Xen_check_type(Xen_is_GLfloat_(buffer), buffer, 3, "glFeedbackBuffer", "GLfloat*"); 2821 glFeedbackBuffer(Xen_to_C_GLsizei(size), Xen_to_C_GLenum(type), Xen_to_C_GLfloat_(buffer)); 2822 return(Xen_false); 2823 } 2824 2825 static Xen gxg_glPassThrough(Xen token) 2826 { 2827 #define H_glPassThrough "void glPassThrough(GLfloat token)" 2828 Xen_check_type(Xen_is_GLfloat(token), token, 1, "glPassThrough", "GLfloat"); 2829 glPassThrough(Xen_to_C_GLfloat(token)); 2830 return(Xen_false); 2831 } 2832 2833 static Xen gxg_glSelectBuffer(Xen size, Xen buffer) 2834 { 2835 #define H_glSelectBuffer "void glSelectBuffer(GLsizei size, GLuint* buffer)" 2836 Xen_check_type(Xen_is_GLsizei(size), size, 1, "glSelectBuffer", "GLsizei"); 2837 Xen_check_type(Xen_is_GLuint_(buffer), buffer, 2, "glSelectBuffer", "GLuint*"); 2838 glSelectBuffer(Xen_to_C_GLsizei(size), Xen_to_C_GLuint_(buffer)); 2839 return(Xen_false); 2840 } 2841 2842 static Xen gxg_glInitNames(void) 2843 { 2844 #define H_glInitNames "void glInitNames( void)" 2845 glInitNames(); 2846 return(Xen_false); 2847 } 2848 2849 static Xen gxg_glLoadName(Xen name) 2850 { 2851 #define H_glLoadName "void glLoadName(GLuint name)" 2852 Xen_check_type(Xen_is_GLuint(name), name, 1, "glLoadName", "GLuint"); 2853 glLoadName(Xen_to_C_GLuint(name)); 2854 return(Xen_false); 2855 } 2856 2857 static Xen gxg_glPushName(Xen name) 2858 { 2859 #define H_glPushName "void glPushName(GLuint name)" 2860 Xen_check_type(Xen_is_GLuint(name), name, 1, "glPushName", "GLuint"); 2861 glPushName(Xen_to_C_GLuint(name)); 2862 return(Xen_false); 2863 } 2864 2865 static Xen gxg_glPopName(void) 2866 { 2867 #define H_glPopName "void glPopName( void)" 2868 glPopName(); 2869 return(Xen_false); 2870 } 2871 2872 static Xen gxg_glDrawRangeElements(Xen mode, Xen start, Xen end, Xen count, Xen type, Xen indices) 2873 { 2874 #define H_glDrawRangeElements "void glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, \ 2875 GLenum type, GLvoid* indices)" 2876 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glDrawRangeElements", "GLenum"); 2877 Xen_check_type(Xen_is_GLuint(start), start, 2, "glDrawRangeElements", "GLuint"); 2878 Xen_check_type(Xen_is_GLuint(end), end, 3, "glDrawRangeElements", "GLuint"); 2879 Xen_check_type(Xen_is_GLsizei(count), count, 4, "glDrawRangeElements", "GLsizei"); 2880 Xen_check_type(Xen_is_GLenum(type), type, 5, "glDrawRangeElements", "GLenum"); 2881 Xen_check_type(Xen_is_GLvoid_(indices), indices, 6, "glDrawRangeElements", "GLvoid*"); 2882 glDrawRangeElements(Xen_to_C_GLenum(mode), Xen_to_C_GLuint(start), Xen_to_C_GLuint(end), Xen_to_C_GLsizei(count), Xen_to_C_GLenum(type), 2883 Xen_to_C_GLvoid_(indices)); 2884 return(Xen_false); 2885 } 2886 2887 static Xen gxg_glTexImage3D(Xen arglist) 2888 { 2889 #define H_glTexImage3D "void glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, \ 2890 GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLvoid* pixels)" 2891 Xen target, level, internalFormat, width, height, depth, border, format, type, pixels; 2892 target = Xen_list_ref(arglist, 0); 2893 level = Xen_list_ref(arglist, 1); 2894 internalFormat = Xen_list_ref(arglist, 2); 2895 width = Xen_list_ref(arglist, 3); 2896 height = Xen_list_ref(arglist, 4); 2897 depth = Xen_list_ref(arglist, 5); 2898 border = Xen_list_ref(arglist, 6); 2899 format = Xen_list_ref(arglist, 7); 2900 type = Xen_list_ref(arglist, 8); 2901 pixels = Xen_list_ref(arglist, 9); 2902 Xen_check_type(Xen_is_GLenum(target), target, 1, "glTexImage3D", "GLenum"); 2903 Xen_check_type(Xen_is_GLint(level), level, 2, "glTexImage3D", "GLint"); 2904 Xen_check_type(Xen_is_GLint(internalFormat), internalFormat, 3, "glTexImage3D", "GLint"); 2905 Xen_check_type(Xen_is_GLsizei(width), width, 4, "glTexImage3D", "GLsizei"); 2906 Xen_check_type(Xen_is_GLsizei(height), height, 5, "glTexImage3D", "GLsizei"); 2907 Xen_check_type(Xen_is_GLsizei(depth), depth, 6, "glTexImage3D", "GLsizei"); 2908 Xen_check_type(Xen_is_GLint(border), border, 7, "glTexImage3D", "GLint"); 2909 Xen_check_type(Xen_is_GLenum(format), format, 8, "glTexImage3D", "GLenum"); 2910 Xen_check_type(Xen_is_GLenum(type), type, 9, "glTexImage3D", "GLenum"); 2911 Xen_check_type(Xen_is_GLvoid_(pixels), pixels, 10, "glTexImage3D", "GLvoid*"); 2912 glTexImage3D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLint(internalFormat), Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height), 2913 Xen_to_C_GLsizei(depth), Xen_to_C_GLint(border), Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(pixels)); 2914 return(Xen_false); 2915 } 2916 2917 static Xen gxg_glTexSubImage3D(Xen arglist) 2918 { 2919 #define H_glTexSubImage3D "void glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, \ 2920 GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* pixels)" 2921 Xen target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels; 2922 target = Xen_list_ref(arglist, 0); 2923 level = Xen_list_ref(arglist, 1); 2924 xoffset = Xen_list_ref(arglist, 2); 2925 yoffset = Xen_list_ref(arglist, 3); 2926 zoffset = Xen_list_ref(arglist, 4); 2927 width = Xen_list_ref(arglist, 5); 2928 height = Xen_list_ref(arglist, 6); 2929 depth = Xen_list_ref(arglist, 7); 2930 format = Xen_list_ref(arglist, 8); 2931 type = Xen_list_ref(arglist, 9); 2932 pixels = Xen_list_ref(arglist, 10); 2933 Xen_check_type(Xen_is_GLenum(target), target, 1, "glTexSubImage3D", "GLenum"); 2934 Xen_check_type(Xen_is_GLint(level), level, 2, "glTexSubImage3D", "GLint"); 2935 Xen_check_type(Xen_is_GLint(xoffset), xoffset, 3, "glTexSubImage3D", "GLint"); 2936 Xen_check_type(Xen_is_GLint(yoffset), yoffset, 4, "glTexSubImage3D", "GLint"); 2937 Xen_check_type(Xen_is_GLint(zoffset), zoffset, 5, "glTexSubImage3D", "GLint"); 2938 Xen_check_type(Xen_is_GLsizei(width), width, 6, "glTexSubImage3D", "GLsizei"); 2939 Xen_check_type(Xen_is_GLsizei(height), height, 7, "glTexSubImage3D", "GLsizei"); 2940 Xen_check_type(Xen_is_GLsizei(depth), depth, 8, "glTexSubImage3D", "GLsizei"); 2941 Xen_check_type(Xen_is_GLenum(format), format, 9, "glTexSubImage3D", "GLenum"); 2942 Xen_check_type(Xen_is_GLenum(type), type, 10, "glTexSubImage3D", "GLenum"); 2943 Xen_check_type(Xen_is_GLvoid_(pixels), pixels, 11, "glTexSubImage3D", "GLvoid*"); 2944 glTexSubImage3D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLint(xoffset), Xen_to_C_GLint(yoffset), Xen_to_C_GLint(zoffset), 2945 Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height), Xen_to_C_GLsizei(depth), Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), 2946 Xen_to_C_GLvoid_(pixels)); 2947 return(Xen_false); 2948 } 2949 2950 static Xen gxg_glCopyTexSubImage3D(Xen arglist) 2951 { 2952 #define H_glCopyTexSubImage3D "void glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, \ 2953 GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)" 2954 Xen target, level, xoffset, yoffset, zoffset, x, y, width, height; 2955 target = Xen_list_ref(arglist, 0); 2956 level = Xen_list_ref(arglist, 1); 2957 xoffset = Xen_list_ref(arglist, 2); 2958 yoffset = Xen_list_ref(arglist, 3); 2959 zoffset = Xen_list_ref(arglist, 4); 2960 x = Xen_list_ref(arglist, 5); 2961 y = Xen_list_ref(arglist, 6); 2962 width = Xen_list_ref(arglist, 7); 2963 height = Xen_list_ref(arglist, 8); 2964 Xen_check_type(Xen_is_GLenum(target), target, 1, "glCopyTexSubImage3D", "GLenum"); 2965 Xen_check_type(Xen_is_GLint(level), level, 2, "glCopyTexSubImage3D", "GLint"); 2966 Xen_check_type(Xen_is_GLint(xoffset), xoffset, 3, "glCopyTexSubImage3D", "GLint"); 2967 Xen_check_type(Xen_is_GLint(yoffset), yoffset, 4, "glCopyTexSubImage3D", "GLint"); 2968 Xen_check_type(Xen_is_GLint(zoffset), zoffset, 5, "glCopyTexSubImage3D", "GLint"); 2969 Xen_check_type(Xen_is_GLint(x), x, 6, "glCopyTexSubImage3D", "GLint"); 2970 Xen_check_type(Xen_is_GLint(y), y, 7, "glCopyTexSubImage3D", "GLint"); 2971 Xen_check_type(Xen_is_GLsizei(width), width, 8, "glCopyTexSubImage3D", "GLsizei"); 2972 Xen_check_type(Xen_is_GLsizei(height), height, 9, "glCopyTexSubImage3D", "GLsizei"); 2973 glCopyTexSubImage3D(Xen_to_C_GLenum(target), Xen_to_C_GLint(level), Xen_to_C_GLint(xoffset), Xen_to_C_GLint(yoffset), Xen_to_C_GLint(zoffset), 2974 Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height)); 2975 return(Xen_false); 2976 } 2977 2978 static Xen gxg_glColorTable(Xen target, Xen internalformat, Xen width, Xen format, Xen type, Xen table) 2979 { 2980 #define H_glColorTable "void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, \ 2981 GLenum type, GLvoid* table)" 2982 Xen_check_type(Xen_is_GLenum(target), target, 1, "glColorTable", "GLenum"); 2983 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 2, "glColorTable", "GLenum"); 2984 Xen_check_type(Xen_is_GLsizei(width), width, 3, "glColorTable", "GLsizei"); 2985 Xen_check_type(Xen_is_GLenum(format), format, 4, "glColorTable", "GLenum"); 2986 Xen_check_type(Xen_is_GLenum(type), type, 5, "glColorTable", "GLenum"); 2987 Xen_check_type(Xen_is_GLvoid_(table), table, 6, "glColorTable", "GLvoid*"); 2988 glColorTable(Xen_to_C_GLenum(target), Xen_to_C_GLenum(internalformat), Xen_to_C_GLsizei(width), Xen_to_C_GLenum(format), 2989 Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(table)); 2990 return(Xen_false); 2991 } 2992 2993 static Xen gxg_glColorSubTable(Xen target, Xen start, Xen count, Xen format, Xen type, Xen data) 2994 { 2995 #define H_glColorSubTable "void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, \ 2996 GLenum type, GLvoid* data)" 2997 Xen_check_type(Xen_is_GLenum(target), target, 1, "glColorSubTable", "GLenum"); 2998 Xen_check_type(Xen_is_GLsizei(start), start, 2, "glColorSubTable", "GLsizei"); 2999 Xen_check_type(Xen_is_GLsizei(count), count, 3, "glColorSubTable", "GLsizei"); 3000 Xen_check_type(Xen_is_GLenum(format), format, 4, "glColorSubTable", "GLenum"); 3001 Xen_check_type(Xen_is_GLenum(type), type, 5, "glColorSubTable", "GLenum"); 3002 Xen_check_type(Xen_is_GLvoid_(data), data, 6, "glColorSubTable", "GLvoid*"); 3003 glColorSubTable(Xen_to_C_GLenum(target), Xen_to_C_GLsizei(start), Xen_to_C_GLsizei(count), Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), 3004 Xen_to_C_GLvoid_(data)); 3005 return(Xen_false); 3006 } 3007 3008 static Xen gxg_glCopyColorSubTable(Xen target, Xen start, Xen x, Xen y, Xen width) 3009 { 3010 #define H_glCopyColorSubTable "void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, \ 3011 GLsizei width)" 3012 Xen_check_type(Xen_is_GLenum(target), target, 1, "glCopyColorSubTable", "GLenum"); 3013 Xen_check_type(Xen_is_GLsizei(start), start, 2, "glCopyColorSubTable", "GLsizei"); 3014 Xen_check_type(Xen_is_GLint(x), x, 3, "glCopyColorSubTable", "GLint"); 3015 Xen_check_type(Xen_is_GLint(y), y, 4, "glCopyColorSubTable", "GLint"); 3016 Xen_check_type(Xen_is_GLsizei(width), width, 5, "glCopyColorSubTable", "GLsizei"); 3017 glCopyColorSubTable(Xen_to_C_GLenum(target), Xen_to_C_GLsizei(start), Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLsizei(width)); 3018 return(Xen_false); 3019 } 3020 3021 static Xen gxg_glCopyColorTable(Xen target, Xen internalformat, Xen x, Xen y, Xen width) 3022 { 3023 #define H_glCopyColorTable "void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, \ 3024 GLsizei width)" 3025 Xen_check_type(Xen_is_GLenum(target), target, 1, "glCopyColorTable", "GLenum"); 3026 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 2, "glCopyColorTable", "GLenum"); 3027 Xen_check_type(Xen_is_GLint(x), x, 3, "glCopyColorTable", "GLint"); 3028 Xen_check_type(Xen_is_GLint(y), y, 4, "glCopyColorTable", "GLint"); 3029 Xen_check_type(Xen_is_GLsizei(width), width, 5, "glCopyColorTable", "GLsizei"); 3030 glCopyColorTable(Xen_to_C_GLenum(target), Xen_to_C_GLenum(internalformat), Xen_to_C_GLint(x), Xen_to_C_GLint(y), Xen_to_C_GLsizei(width)); 3031 return(Xen_false); 3032 } 3033 3034 static Xen gxg_glGetColorTableParameterfv(Xen target, Xen pname, Xen params) 3035 { 3036 #define H_glGetColorTableParameterfv "void glGetColorTableParameterfv(GLenum target, GLenum pname, \ 3037 GLfloat* [params])" 3038 GLfloat ref_params[1]; 3039 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetColorTableParameterfv", "GLenum"); 3040 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetColorTableParameterfv", "GLenum"); 3041 glGetColorTableParameterfv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), ref_params); 3042 return(Xen_list_1(C_to_Xen_GLfloat(ref_params[0]))); 3043 } 3044 3045 static Xen gxg_glGetColorTableParameteriv(Xen target, Xen pname, Xen params) 3046 { 3047 #define H_glGetColorTableParameteriv "void glGetColorTableParameteriv(GLenum target, GLenum pname, \ 3048 GLint* [params])" 3049 GLint ref_params[1]; 3050 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetColorTableParameteriv", "GLenum"); 3051 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetColorTableParameteriv", "GLenum"); 3052 glGetColorTableParameteriv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), ref_params); 3053 return(Xen_list_1(C_to_Xen_GLint(ref_params[0]))); 3054 } 3055 3056 static Xen gxg_glBlendEquation(Xen mode) 3057 { 3058 #define H_glBlendEquation "void glBlendEquation(GLenum mode)" 3059 Xen_check_type(Xen_is_GLenum(mode), mode, 1, "glBlendEquation", "GLenum"); 3060 glBlendEquation(Xen_to_C_GLenum(mode)); 3061 return(Xen_false); 3062 } 3063 3064 static Xen gxg_glBlendColor(Xen red, Xen green, Xen blue, Xen alpha) 3065 { 3066 #define H_glBlendColor "void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)" 3067 Xen_check_type(Xen_is_GLclampf(red), red, 1, "glBlendColor", "GLclampf"); 3068 Xen_check_type(Xen_is_GLclampf(green), green, 2, "glBlendColor", "GLclampf"); 3069 Xen_check_type(Xen_is_GLclampf(blue), blue, 3, "glBlendColor", "GLclampf"); 3070 Xen_check_type(Xen_is_GLclampf(alpha), alpha, 4, "glBlendColor", "GLclampf"); 3071 glBlendColor(Xen_to_C_GLclampf(red), Xen_to_C_GLclampf(green), Xen_to_C_GLclampf(blue), Xen_to_C_GLclampf(alpha)); 3072 return(Xen_false); 3073 } 3074 3075 static Xen gxg_glHistogram(Xen target, Xen width, Xen internalformat, Xen sink) 3076 { 3077 #define H_glHistogram "void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)" 3078 Xen_check_type(Xen_is_GLenum(target), target, 1, "glHistogram", "GLenum"); 3079 Xen_check_type(Xen_is_GLsizei(width), width, 2, "glHistogram", "GLsizei"); 3080 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 3, "glHistogram", "GLenum"); 3081 Xen_check_type(Xen_is_GLboolean(sink), sink, 4, "glHistogram", "GLboolean"); 3082 glHistogram(Xen_to_C_GLenum(target), Xen_to_C_GLsizei(width), Xen_to_C_GLenum(internalformat), Xen_to_C_GLboolean(sink)); 3083 return(Xen_false); 3084 } 3085 3086 static Xen gxg_glResetHistogram(Xen target) 3087 { 3088 #define H_glResetHistogram "void glResetHistogram(GLenum target)" 3089 Xen_check_type(Xen_is_GLenum(target), target, 1, "glResetHistogram", "GLenum"); 3090 glResetHistogram(Xen_to_C_GLenum(target)); 3091 return(Xen_false); 3092 } 3093 3094 static Xen gxg_glGetHistogram(Xen target, Xen reset, Xen format, Xen type, Xen values) 3095 { 3096 #define H_glGetHistogram "void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, \ 3097 GLvoid* values)" 3098 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetHistogram", "GLenum"); 3099 Xen_check_type(Xen_is_GLboolean(reset), reset, 2, "glGetHistogram", "GLboolean"); 3100 Xen_check_type(Xen_is_GLenum(format), format, 3, "glGetHistogram", "GLenum"); 3101 Xen_check_type(Xen_is_GLenum(type), type, 4, "glGetHistogram", "GLenum"); 3102 Xen_check_type(Xen_is_GLvoid_(values), values, 5, "glGetHistogram", "GLvoid*"); 3103 glGetHistogram(Xen_to_C_GLenum(target), Xen_to_C_GLboolean(reset), Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(values)); 3104 return(Xen_false); 3105 } 3106 3107 static Xen gxg_glGetHistogramParameterfv(Xen target, Xen pname, Xen params) 3108 { 3109 #define H_glGetHistogramParameterfv "void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat* [params])" 3110 GLfloat ref_params[1]; 3111 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetHistogramParameterfv", "GLenum"); 3112 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetHistogramParameterfv", "GLenum"); 3113 glGetHistogramParameterfv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), ref_params); 3114 return(Xen_list_1(C_to_Xen_GLfloat(ref_params[0]))); 3115 } 3116 3117 static Xen gxg_glGetHistogramParameteriv(Xen target, Xen pname, Xen params) 3118 { 3119 #define H_glGetHistogramParameteriv "void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint* [params])" 3120 GLint ref_params[1]; 3121 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetHistogramParameteriv", "GLenum"); 3122 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetHistogramParameteriv", "GLenum"); 3123 glGetHistogramParameteriv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), ref_params); 3124 return(Xen_list_1(C_to_Xen_GLint(ref_params[0]))); 3125 } 3126 3127 static Xen gxg_glMinmax(Xen target, Xen internalformat, Xen sink) 3128 { 3129 #define H_glMinmax "void glMinmax(GLenum target, GLenum internalformat, GLboolean sink)" 3130 Xen_check_type(Xen_is_GLenum(target), target, 1, "glMinmax", "GLenum"); 3131 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 2, "glMinmax", "GLenum"); 3132 Xen_check_type(Xen_is_GLboolean(sink), sink, 3, "glMinmax", "GLboolean"); 3133 glMinmax(Xen_to_C_GLenum(target), Xen_to_C_GLenum(internalformat), Xen_to_C_GLboolean(sink)); 3134 return(Xen_false); 3135 } 3136 3137 static Xen gxg_glResetMinmax(Xen target) 3138 { 3139 #define H_glResetMinmax "void glResetMinmax(GLenum target)" 3140 Xen_check_type(Xen_is_GLenum(target), target, 1, "glResetMinmax", "GLenum"); 3141 glResetMinmax(Xen_to_C_GLenum(target)); 3142 return(Xen_false); 3143 } 3144 3145 static Xen gxg_glGetMinmax(Xen target, Xen reset, Xen format, Xen types, Xen values) 3146 { 3147 #define H_glGetMinmax "void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum types, \ 3148 GLvoid* values)" 3149 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetMinmax", "GLenum"); 3150 Xen_check_type(Xen_is_GLboolean(reset), reset, 2, "glGetMinmax", "GLboolean"); 3151 Xen_check_type(Xen_is_GLenum(format), format, 3, "glGetMinmax", "GLenum"); 3152 Xen_check_type(Xen_is_GLenum(types), types, 4, "glGetMinmax", "GLenum"); 3153 Xen_check_type(Xen_is_GLvoid_(values), values, 5, "glGetMinmax", "GLvoid*"); 3154 glGetMinmax(Xen_to_C_GLenum(target), Xen_to_C_GLboolean(reset), Xen_to_C_GLenum(format), Xen_to_C_GLenum(types), Xen_to_C_GLvoid_(values)); 3155 return(Xen_false); 3156 } 3157 3158 static Xen gxg_glGetMinmaxParameterfv(Xen target, Xen pname, Xen params) 3159 { 3160 #define H_glGetMinmaxParameterfv "void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat* [params])" 3161 GLfloat ref_params[1]; 3162 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetMinmaxParameterfv", "GLenum"); 3163 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetMinmaxParameterfv", "GLenum"); 3164 glGetMinmaxParameterfv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), ref_params); 3165 return(Xen_list_1(C_to_Xen_GLfloat(ref_params[0]))); 3166 } 3167 3168 static Xen gxg_glGetMinmaxParameteriv(Xen target, Xen pname, Xen params) 3169 { 3170 #define H_glGetMinmaxParameteriv "void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint* [params])" 3171 GLint ref_params[1]; 3172 Xen_check_type(Xen_is_GLenum(target), target, 1, "glGetMinmaxParameteriv", "GLenum"); 3173 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glGetMinmaxParameteriv", "GLenum"); 3174 glGetMinmaxParameteriv(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), ref_params); 3175 return(Xen_list_1(C_to_Xen_GLint(ref_params[0]))); 3176 } 3177 3178 static Xen gxg_glConvolutionFilter1D(Xen target, Xen internalformat, Xen width, Xen format, Xen type, Xen image) 3179 { 3180 #define H_glConvolutionFilter1D "void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, \ 3181 GLenum format, GLenum type, GLvoid* image)" 3182 Xen_check_type(Xen_is_GLenum(target), target, 1, "glConvolutionFilter1D", "GLenum"); 3183 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 2, "glConvolutionFilter1D", "GLenum"); 3184 Xen_check_type(Xen_is_GLsizei(width), width, 3, "glConvolutionFilter1D", "GLsizei"); 3185 Xen_check_type(Xen_is_GLenum(format), format, 4, "glConvolutionFilter1D", "GLenum"); 3186 Xen_check_type(Xen_is_GLenum(type), type, 5, "glConvolutionFilter1D", "GLenum"); 3187 Xen_check_type(Xen_is_GLvoid_(image), image, 6, "glConvolutionFilter1D", "GLvoid*"); 3188 glConvolutionFilter1D(Xen_to_C_GLenum(target), Xen_to_C_GLenum(internalformat), Xen_to_C_GLsizei(width), Xen_to_C_GLenum(format), 3189 Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(image)); 3190 return(Xen_false); 3191 } 3192 3193 static Xen gxg_glConvolutionFilter2D(Xen target, Xen internalformat, Xen width, Xen height, Xen format, Xen type, Xen image) 3194 { 3195 #define H_glConvolutionFilter2D "void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, \ 3196 GLsizei height, GLenum format, GLenum type, GLvoid* image)" 3197 Xen_check_type(Xen_is_GLenum(target), target, 1, "glConvolutionFilter2D", "GLenum"); 3198 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 2, "glConvolutionFilter2D", "GLenum"); 3199 Xen_check_type(Xen_is_GLsizei(width), width, 3, "glConvolutionFilter2D", "GLsizei"); 3200 Xen_check_type(Xen_is_GLsizei(height), height, 4, "glConvolutionFilter2D", "GLsizei"); 3201 Xen_check_type(Xen_is_GLenum(format), format, 5, "glConvolutionFilter2D", "GLenum"); 3202 Xen_check_type(Xen_is_GLenum(type), type, 6, "glConvolutionFilter2D", "GLenum"); 3203 Xen_check_type(Xen_is_GLvoid_(image), image, 7, "glConvolutionFilter2D", "GLvoid*"); 3204 glConvolutionFilter2D(Xen_to_C_GLenum(target), Xen_to_C_GLenum(internalformat), Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height), 3205 Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(image)); 3206 return(Xen_false); 3207 } 3208 3209 static Xen gxg_glConvolutionParameterf(Xen target, Xen pname, Xen params) 3210 { 3211 #define H_glConvolutionParameterf "void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)" 3212 Xen_check_type(Xen_is_GLenum(target), target, 1, "glConvolutionParameterf", "GLenum"); 3213 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glConvolutionParameterf", "GLenum"); 3214 Xen_check_type(Xen_is_GLfloat(params), params, 3, "glConvolutionParameterf", "GLfloat"); 3215 glConvolutionParameterf(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), Xen_to_C_GLfloat(params)); 3216 return(Xen_false); 3217 } 3218 3219 static Xen gxg_glConvolutionParameteri(Xen target, Xen pname, Xen params) 3220 { 3221 #define H_glConvolutionParameteri "void glConvolutionParameteri(GLenum target, GLenum pname, GLint params)" 3222 Xen_check_type(Xen_is_GLenum(target), target, 1, "glConvolutionParameteri", "GLenum"); 3223 Xen_check_type(Xen_is_GLenum(pname), pname, 2, "glConvolutionParameteri", "GLenum"); 3224 Xen_check_type(Xen_is_GLint(params), params, 3, "glConvolutionParameteri", "GLint"); 3225 glConvolutionParameteri(Xen_to_C_GLenum(target), Xen_to_C_GLenum(pname), Xen_to_C_GLint(params)); 3226 return(Xen_false); 3227 } 3228 3229 static Xen gxg_glCopyConvolutionFilter1D(Xen target, Xen internalformat, Xen x, Xen y, Xen width) 3230 { 3231 #define H_glCopyConvolutionFilter1D "void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, \ 3232 GLint x, GLint y, GLsizei width)" 3233 Xen_check_type(Xen_is_GLenum(target), target, 1, "glCopyConvolutionFilter1D", "GLenum"); 3234 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 2, "glCopyConvolutionFilter1D", "GLenum"); 3235 Xen_check_type(Xen_is_GLint(x), x, 3, "glCopyConvolutionFilter1D", "GLint"); 3236 Xen_check_type(Xen_is_GLint(y), y, 4, "glCopyConvolutionFilter1D", "GLint"); 3237 Xen_check_type(Xen_is_GLsizei(width), width, 5, "glCopyConvolutionFilter1D", "GLsizei"); 3238 glCopyConvolutionFilter1D(Xen_to_C_GLenum(target), Xen_to_C_GLenum(internalformat), Xen_to_C_GLint(x), Xen_to_C_GLint(y), 3239 Xen_to_C_GLsizei(width)); 3240 return(Xen_false); 3241 } 3242 3243 static Xen gxg_glCopyConvolutionFilter2D(Xen target, Xen internalformat, Xen x, Xen y, Xen width, Xen height) 3244 { 3245 #define H_glCopyConvolutionFilter2D "void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, \ 3246 GLint x, GLint y, GLsizei width, GLsizei height)" 3247 Xen_check_type(Xen_is_GLenum(target), target, 1, "glCopyConvolutionFilter2D", "GLenum"); 3248 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 2, "glCopyConvolutionFilter2D", "GLenum"); 3249 Xen_check_type(Xen_is_GLint(x), x, 3, "glCopyConvolutionFilter2D", "GLint"); 3250 Xen_check_type(Xen_is_GLint(y), y, 4, "glCopyConvolutionFilter2D", "GLint"); 3251 Xen_check_type(Xen_is_GLsizei(width), width, 5, "glCopyConvolutionFilter2D", "GLsizei"); 3252 Xen_check_type(Xen_is_GLsizei(height), height, 6, "glCopyConvolutionFilter2D", "GLsizei"); 3253 glCopyConvolutionFilter2D(Xen_to_C_GLenum(target), Xen_to_C_GLenum(internalformat), Xen_to_C_GLint(x), Xen_to_C_GLint(y), 3254 Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height)); 3255 return(Xen_false); 3256 } 3257 3258 static Xen gxg_glSeparableFilter2D(Xen arglist) 3259 { 3260 #define H_glSeparableFilter2D "void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, \ 3261 GLsizei height, GLenum format, GLenum type, GLvoid* row, GLvoid* column)" 3262 Xen target, internalformat, width, height, format, type, row, column; 3263 target = Xen_list_ref(arglist, 0); 3264 internalformat = Xen_list_ref(arglist, 1); 3265 width = Xen_list_ref(arglist, 2); 3266 height = Xen_list_ref(arglist, 3); 3267 format = Xen_list_ref(arglist, 4); 3268 type = Xen_list_ref(arglist, 5); 3269 row = Xen_list_ref(arglist, 6); 3270 column = Xen_list_ref(arglist, 7); 3271 Xen_check_type(Xen_is_GLenum(target), target, 1, "glSeparableFilter2D", "GLenum"); 3272 Xen_check_type(Xen_is_GLenum(internalformat), internalformat, 2, "glSeparableFilter2D", "GLenum"); 3273 Xen_check_type(Xen_is_GLsizei(width), width, 3, "glSeparableFilter2D", "GLsizei"); 3274 Xen_check_type(Xen_is_GLsizei(height), height, 4, "glSeparableFilter2D", "GLsizei"); 3275 Xen_check_type(Xen_is_GLenum(format), format, 5, "glSeparableFilter2D", "GLenum"); 3276 Xen_check_type(Xen_is_GLenum(type), type, 6, "glSeparableFilter2D", "GLenum"); 3277 Xen_check_type(Xen_is_GLvoid_(row), row, 7, "glSeparableFilter2D", "GLvoid*"); 3278 Xen_check_type(Xen_is_GLvoid_(column), column, 8, "glSeparableFilter2D", "GLvoid*"); 3279 glSeparableFilter2D(Xen_to_C_GLenum(target), Xen_to_C_GLenum(internalformat), Xen_to_C_GLsizei(width), Xen_to_C_GLsizei(height), 3280 Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_GLvoid_(row), Xen_to_C_GLvoid_(column)); 3281 return(Xen_false); 3282 } 3283 3284 #if HAVE_GLU 3285 static Xen gxg_gluBeginCurve(Xen nurb) 3286 { 3287 #define H_gluBeginCurve "void gluBeginCurve(GLUnurbs* nurb)" 3288 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluBeginCurve", "GLUnurbs*"); 3289 gluBeginCurve(Xen_to_C_GLUnurbs_(nurb)); 3290 return(Xen_false); 3291 } 3292 3293 #ifdef GLU_VERSION_1_2 3294 static Xen gxg_gluBeginPolygon(Xen tess) 3295 { 3296 #define H_gluBeginPolygon "void gluBeginPolygon(GLUtesselator* tess)" 3297 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluBeginPolygon", "GLUtesselator*"); 3298 gluBeginPolygon(Xen_to_C_GLUtesselator_(tess)); 3299 return(Xen_false); 3300 } 3301 #endif 3302 3303 static Xen gxg_gluBeginSurface(Xen nurb) 3304 { 3305 #define H_gluBeginSurface "void gluBeginSurface(GLUnurbs* nurb)" 3306 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluBeginSurface", "GLUnurbs*"); 3307 gluBeginSurface(Xen_to_C_GLUnurbs_(nurb)); 3308 return(Xen_false); 3309 } 3310 3311 static Xen gxg_gluBeginTrim(Xen nurb) 3312 { 3313 #define H_gluBeginTrim "void gluBeginTrim(GLUnurbs* nurb)" 3314 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluBeginTrim", "GLUnurbs*"); 3315 gluBeginTrim(Xen_to_C_GLUnurbs_(nurb)); 3316 return(Xen_false); 3317 } 3318 3319 static Xen gxg_gluBuild1DMipmapLevels(Xen arglist) 3320 { 3321 #define H_gluBuild1DMipmapLevels "GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, \ 3322 GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, void* data)" 3323 Xen target, internalFormat, width, format, type, level, base, max, data; 3324 target = Xen_list_ref(arglist, 0); 3325 internalFormat = Xen_list_ref(arglist, 1); 3326 width = Xen_list_ref(arglist, 2); 3327 format = Xen_list_ref(arglist, 3); 3328 type = Xen_list_ref(arglist, 4); 3329 level = Xen_list_ref(arglist, 5); 3330 base = Xen_list_ref(arglist, 6); 3331 max = Xen_list_ref(arglist, 7); 3332 data = Xen_list_ref(arglist, 8); 3333 Xen_check_type(Xen_is_GLenum(target), target, 1, "gluBuild1DMipmapLevels", "GLenum"); 3334 Xen_check_type(Xen_is_GLint(internalFormat), internalFormat, 2, "gluBuild1DMipmapLevels", "GLint"); 3335 Xen_check_type(Xen_is_GLsizei(width), width, 3, "gluBuild1DMipmapLevels", "GLsizei"); 3336 Xen_check_type(Xen_is_GLenum(format), format, 4, "gluBuild1DMipmapLevels", "GLenum"); 3337 Xen_check_type(Xen_is_GLenum(type), type, 5, "gluBuild1DMipmapLevels", "GLenum"); 3338 Xen_check_type(Xen_is_GLint(level), level, 6, "gluBuild1DMipmapLevels", "GLint"); 3339 Xen_check_type(Xen_is_GLint(base), base, 7, "gluBuild1DMipmapLevels", "GLint"); 3340 Xen_check_type(Xen_is_GLint(max), max, 8, "gluBuild1DMipmapLevels", "GLint"); 3341 Xen_check_type(Xen_is_void_(data), data, 9, "gluBuild1DMipmapLevels", "void*"); 3342 return(C_to_Xen_GLint(gluBuild1DMipmapLevels(Xen_to_C_GLenum(target), Xen_to_C_GLint(internalFormat), Xen_to_C_GLsizei(width), 3343 Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_GLint(level), Xen_to_C_GLint(base), 3344 Xen_to_C_GLint(max), Xen_to_C_void_(data)))); 3345 } 3346 3347 static Xen gxg_gluBuild1DMipmaps(Xen target, Xen internalFormat, Xen width, Xen format, Xen type, Xen data) 3348 { 3349 #define H_gluBuild1DMipmaps "GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, \ 3350 GLenum format, GLenum type, void* data)" 3351 Xen_check_type(Xen_is_GLenum(target), target, 1, "gluBuild1DMipmaps", "GLenum"); 3352 Xen_check_type(Xen_is_GLint(internalFormat), internalFormat, 2, "gluBuild1DMipmaps", "GLint"); 3353 Xen_check_type(Xen_is_GLsizei(width), width, 3, "gluBuild1DMipmaps", "GLsizei"); 3354 Xen_check_type(Xen_is_GLenum(format), format, 4, "gluBuild1DMipmaps", "GLenum"); 3355 Xen_check_type(Xen_is_GLenum(type), type, 5, "gluBuild1DMipmaps", "GLenum"); 3356 Xen_check_type(Xen_is_void_(data), data, 6, "gluBuild1DMipmaps", "void*"); 3357 return(C_to_Xen_GLint(gluBuild1DMipmaps(Xen_to_C_GLenum(target), Xen_to_C_GLint(internalFormat), Xen_to_C_GLsizei(width), 3358 Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_void_(data)))); 3359 } 3360 3361 static Xen gxg_gluBuild2DMipmapLevels(Xen arglist) 3362 { 3363 #define H_gluBuild2DMipmapLevels "GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, \ 3364 GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, void* data)" 3365 Xen target, internalFormat, width, height, format, type, level, base, max, data; 3366 target = Xen_list_ref(arglist, 0); 3367 internalFormat = Xen_list_ref(arglist, 1); 3368 width = Xen_list_ref(arglist, 2); 3369 height = Xen_list_ref(arglist, 3); 3370 format = Xen_list_ref(arglist, 4); 3371 type = Xen_list_ref(arglist, 5); 3372 level = Xen_list_ref(arglist, 6); 3373 base = Xen_list_ref(arglist, 7); 3374 max = Xen_list_ref(arglist, 8); 3375 data = Xen_list_ref(arglist, 9); 3376 Xen_check_type(Xen_is_GLenum(target), target, 1, "gluBuild2DMipmapLevels", "GLenum"); 3377 Xen_check_type(Xen_is_GLint(internalFormat), internalFormat, 2, "gluBuild2DMipmapLevels", "GLint"); 3378 Xen_check_type(Xen_is_GLsizei(width), width, 3, "gluBuild2DMipmapLevels", "GLsizei"); 3379 Xen_check_type(Xen_is_GLsizei(height), height, 4, "gluBuild2DMipmapLevels", "GLsizei"); 3380 Xen_check_type(Xen_is_GLenum(format), format, 5, "gluBuild2DMipmapLevels", "GLenum"); 3381 Xen_check_type(Xen_is_GLenum(type), type, 6, "gluBuild2DMipmapLevels", "GLenum"); 3382 Xen_check_type(Xen_is_GLint(level), level, 7, "gluBuild2DMipmapLevels", "GLint"); 3383 Xen_check_type(Xen_is_GLint(base), base, 8, "gluBuild2DMipmapLevels", "GLint"); 3384 Xen_check_type(Xen_is_GLint(max), max, 9, "gluBuild2DMipmapLevels", "GLint"); 3385 Xen_check_type(Xen_is_void_(data), data, 10, "gluBuild2DMipmapLevels", "void*"); 3386 return(C_to_Xen_GLint(gluBuild2DMipmapLevels(Xen_to_C_GLenum(target), Xen_to_C_GLint(internalFormat), Xen_to_C_GLsizei(width), 3387 Xen_to_C_GLsizei(height), Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), 3388 Xen_to_C_GLint(level), Xen_to_C_GLint(base), Xen_to_C_GLint(max), Xen_to_C_void_(data)))); 3389 } 3390 3391 static Xen gxg_gluBuild2DMipmaps(Xen target, Xen internalFormat, Xen width, Xen height, Xen format, Xen type, Xen data) 3392 { 3393 #define H_gluBuild2DMipmaps "GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, \ 3394 GLsizei height, GLenum format, GLenum type, void* data)" 3395 Xen_check_type(Xen_is_GLenum(target), target, 1, "gluBuild2DMipmaps", "GLenum"); 3396 Xen_check_type(Xen_is_GLint(internalFormat), internalFormat, 2, "gluBuild2DMipmaps", "GLint"); 3397 Xen_check_type(Xen_is_GLsizei(width), width, 3, "gluBuild2DMipmaps", "GLsizei"); 3398 Xen_check_type(Xen_is_GLsizei(height), height, 4, "gluBuild2DMipmaps", "GLsizei"); 3399 Xen_check_type(Xen_is_GLenum(format), format, 5, "gluBuild2DMipmaps", "GLenum"); 3400 Xen_check_type(Xen_is_GLenum(type), type, 6, "gluBuild2DMipmaps", "GLenum"); 3401 Xen_check_type(Xen_is_void_(data), data, 7, "gluBuild2DMipmaps", "void*"); 3402 return(C_to_Xen_GLint(gluBuild2DMipmaps(Xen_to_C_GLenum(target), Xen_to_C_GLint(internalFormat), Xen_to_C_GLsizei(width), 3403 Xen_to_C_GLsizei(height), Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), Xen_to_C_void_(data)))); 3404 } 3405 3406 static Xen gxg_gluBuild3DMipmapLevels(Xen arglist) 3407 { 3408 #define H_gluBuild3DMipmapLevels "GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, \ 3409 GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, \ 3410 void* data)" 3411 Xen target, internalFormat, width, height, depth, format, type, level, base, max, data; 3412 target = Xen_list_ref(arglist, 0); 3413 internalFormat = Xen_list_ref(arglist, 1); 3414 width = Xen_list_ref(arglist, 2); 3415 height = Xen_list_ref(arglist, 3); 3416 depth = Xen_list_ref(arglist, 4); 3417 format = Xen_list_ref(arglist, 5); 3418 type = Xen_list_ref(arglist, 6); 3419 level = Xen_list_ref(arglist, 7); 3420 base = Xen_list_ref(arglist, 8); 3421 max = Xen_list_ref(arglist, 9); 3422 data = Xen_list_ref(arglist, 10); 3423 Xen_check_type(Xen_is_GLenum(target), target, 1, "gluBuild3DMipmapLevels", "GLenum"); 3424 Xen_check_type(Xen_is_GLint(internalFormat), internalFormat, 2, "gluBuild3DMipmapLevels", "GLint"); 3425 Xen_check_type(Xen_is_GLsizei(width), width, 3, "gluBuild3DMipmapLevels", "GLsizei"); 3426 Xen_check_type(Xen_is_GLsizei(height), height, 4, "gluBuild3DMipmapLevels", "GLsizei"); 3427 Xen_check_type(Xen_is_GLsizei(depth), depth, 5, "gluBuild3DMipmapLevels", "GLsizei"); 3428 Xen_check_type(Xen_is_GLenum(format), format, 6, "gluBuild3DMipmapLevels", "GLenum"); 3429 Xen_check_type(Xen_is_GLenum(type), type, 7, "gluBuild3DMipmapLevels", "GLenum"); 3430 Xen_check_type(Xen_is_GLint(level), level, 8, "gluBuild3DMipmapLevels", "GLint"); 3431 Xen_check_type(Xen_is_GLint(base), base, 9, "gluBuild3DMipmapLevels", "GLint"); 3432 Xen_check_type(Xen_is_GLint(max), max, 10, "gluBuild3DMipmapLevels", "GLint"); 3433 Xen_check_type(Xen_is_void_(data), data, 11, "gluBuild3DMipmapLevels", "void*"); 3434 return(C_to_Xen_GLint(gluBuild3DMipmapLevels(Xen_to_C_GLenum(target), Xen_to_C_GLint(internalFormat), Xen_to_C_GLsizei(width), 3435 Xen_to_C_GLsizei(height), Xen_to_C_GLsizei(depth), Xen_to_C_GLenum(format), 3436 Xen_to_C_GLenum(type), Xen_to_C_GLint(level), Xen_to_C_GLint(base), Xen_to_C_GLint(max), 3437 Xen_to_C_void_(data)))); 3438 } 3439 3440 static Xen gxg_gluBuild3DMipmaps(Xen arglist) 3441 { 3442 #define H_gluBuild3DMipmaps "GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, \ 3443 GLsizei height, GLsizei depth, GLenum format, GLenum type, void* data)" 3444 Xen target, internalFormat, width, height, depth, format, type, data; 3445 target = Xen_list_ref(arglist, 0); 3446 internalFormat = Xen_list_ref(arglist, 1); 3447 width = Xen_list_ref(arglist, 2); 3448 height = Xen_list_ref(arglist, 3); 3449 depth = Xen_list_ref(arglist, 4); 3450 format = Xen_list_ref(arglist, 5); 3451 type = Xen_list_ref(arglist, 6); 3452 data = Xen_list_ref(arglist, 7); 3453 Xen_check_type(Xen_is_GLenum(target), target, 1, "gluBuild3DMipmaps", "GLenum"); 3454 Xen_check_type(Xen_is_GLint(internalFormat), internalFormat, 2, "gluBuild3DMipmaps", "GLint"); 3455 Xen_check_type(Xen_is_GLsizei(width), width, 3, "gluBuild3DMipmaps", "GLsizei"); 3456 Xen_check_type(Xen_is_GLsizei(height), height, 4, "gluBuild3DMipmaps", "GLsizei"); 3457 Xen_check_type(Xen_is_GLsizei(depth), depth, 5, "gluBuild3DMipmaps", "GLsizei"); 3458 Xen_check_type(Xen_is_GLenum(format), format, 6, "gluBuild3DMipmaps", "GLenum"); 3459 Xen_check_type(Xen_is_GLenum(type), type, 7, "gluBuild3DMipmaps", "GLenum"); 3460 Xen_check_type(Xen_is_void_(data), data, 8, "gluBuild3DMipmaps", "void*"); 3461 return(C_to_Xen_GLint(gluBuild3DMipmaps(Xen_to_C_GLenum(target), Xen_to_C_GLint(internalFormat), Xen_to_C_GLsizei(width), 3462 Xen_to_C_GLsizei(height), Xen_to_C_GLsizei(depth), Xen_to_C_GLenum(format), Xen_to_C_GLenum(type), 3463 Xen_to_C_void_(data)))); 3464 } 3465 3466 static Xen gxg_gluCheckExtension(Xen extName, Xen extString) 3467 { 3468 #define H_gluCheckExtension "GLboolean gluCheckExtension(GLubyte* extName, GLubyte* extString)" 3469 Xen_check_type(Xen_is_GLubyte_(extName), extName, 1, "gluCheckExtension", "GLubyte*"); 3470 Xen_check_type(Xen_is_GLubyte_(extString), extString, 2, "gluCheckExtension", "GLubyte*"); 3471 return(C_to_Xen_GLboolean(gluCheckExtension(Xen_to_C_GLubyte_(extName), Xen_to_C_GLubyte_(extString)))); 3472 } 3473 3474 static Xen gxg_gluCylinder(Xen quad, Xen base, Xen top, Xen height, Xen slices, Xen stacks) 3475 { 3476 #define H_gluCylinder "void gluCylinder(GLUquadric* quad, GLdouble base, GLdouble top, GLdouble height, \ 3477 GLint slices, GLint stacks)" 3478 Xen_check_type(Xen_is_GLUquadric_(quad), quad, 1, "gluCylinder", "GLUquadric*"); 3479 Xen_check_type(Xen_is_GLdouble(base), base, 2, "gluCylinder", "GLdouble"); 3480 Xen_check_type(Xen_is_GLdouble(top), top, 3, "gluCylinder", "GLdouble"); 3481 Xen_check_type(Xen_is_GLdouble(height), height, 4, "gluCylinder", "GLdouble"); 3482 Xen_check_type(Xen_is_GLint(slices), slices, 5, "gluCylinder", "GLint"); 3483 Xen_check_type(Xen_is_GLint(stacks), stacks, 6, "gluCylinder", "GLint"); 3484 gluCylinder(Xen_to_C_GLUquadric_(quad), Xen_to_C_GLdouble(base), Xen_to_C_GLdouble(top), Xen_to_C_GLdouble(height), Xen_to_C_GLint(slices), 3485 Xen_to_C_GLint(stacks)); 3486 return(Xen_false); 3487 } 3488 3489 static Xen gxg_gluDeleteNurbsRenderer(Xen nurb) 3490 { 3491 #define H_gluDeleteNurbsRenderer "void gluDeleteNurbsRenderer(GLUnurbs* nurb)" 3492 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluDeleteNurbsRenderer", "GLUnurbs*"); 3493 gluDeleteNurbsRenderer(Xen_to_C_GLUnurbs_(nurb)); 3494 return(Xen_false); 3495 } 3496 3497 static Xen gxg_gluDeleteQuadric(Xen quad) 3498 { 3499 #define H_gluDeleteQuadric "void gluDeleteQuadric(GLUquadric* quad)" 3500 Xen_check_type(Xen_is_GLUquadric_(quad), quad, 1, "gluDeleteQuadric", "GLUquadric*"); 3501 gluDeleteQuadric(Xen_to_C_GLUquadric_(quad)); 3502 return(Xen_false); 3503 } 3504 3505 #ifdef GLU_VERSION_1_2 3506 static Xen gxg_gluDeleteTess(Xen tess) 3507 { 3508 #define H_gluDeleteTess "void gluDeleteTess(GLUtesselator* tess)" 3509 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluDeleteTess", "GLUtesselator*"); 3510 gluDeleteTess(Xen_to_C_GLUtesselator_(tess)); 3511 return(Xen_false); 3512 } 3513 #endif 3514 3515 static Xen gxg_gluDisk(Xen quad, Xen inner, Xen outer, Xen slices, Xen loops) 3516 { 3517 #define H_gluDisk "void gluDisk(GLUquadric* quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops)" 3518 Xen_check_type(Xen_is_GLUquadric_(quad), quad, 1, "gluDisk", "GLUquadric*"); 3519 Xen_check_type(Xen_is_GLdouble(inner), inner, 2, "gluDisk", "GLdouble"); 3520 Xen_check_type(Xen_is_GLdouble(outer), outer, 3, "gluDisk", "GLdouble"); 3521 Xen_check_type(Xen_is_GLint(slices), slices, 4, "gluDisk", "GLint"); 3522 Xen_check_type(Xen_is_GLint(loops), loops, 5, "gluDisk", "GLint"); 3523 gluDisk(Xen_to_C_GLUquadric_(quad), Xen_to_C_GLdouble(inner), Xen_to_C_GLdouble(outer), Xen_to_C_GLint(slices), Xen_to_C_GLint(loops)); 3524 return(Xen_false); 3525 } 3526 3527 static Xen gxg_gluEndCurve(Xen nurb) 3528 { 3529 #define H_gluEndCurve "void gluEndCurve(GLUnurbs* nurb)" 3530 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluEndCurve", "GLUnurbs*"); 3531 gluEndCurve(Xen_to_C_GLUnurbs_(nurb)); 3532 return(Xen_false); 3533 } 3534 3535 #ifdef GLU_VERSION_1_2 3536 static Xen gxg_gluEndPolygon(Xen tess) 3537 { 3538 #define H_gluEndPolygon "void gluEndPolygon(GLUtesselator* tess)" 3539 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluEndPolygon", "GLUtesselator*"); 3540 gluEndPolygon(Xen_to_C_GLUtesselator_(tess)); 3541 return(Xen_false); 3542 } 3543 #endif 3544 3545 static Xen gxg_gluEndSurface(Xen nurb) 3546 { 3547 #define H_gluEndSurface "void gluEndSurface(GLUnurbs* nurb)" 3548 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluEndSurface", "GLUnurbs*"); 3549 gluEndSurface(Xen_to_C_GLUnurbs_(nurb)); 3550 return(Xen_false); 3551 } 3552 3553 static Xen gxg_gluEndTrim(Xen nurb) 3554 { 3555 #define H_gluEndTrim "void gluEndTrim(GLUnurbs* nurb)" 3556 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluEndTrim", "GLUnurbs*"); 3557 gluEndTrim(Xen_to_C_GLUnurbs_(nurb)); 3558 return(Xen_false); 3559 } 3560 3561 static Xen gxg_gluErrorString(Xen error) 3562 { 3563 #define H_gluErrorString "constchar* gluErrorString(GLenum error)" 3564 Xen_check_type(Xen_is_GLenum(error), error, 1, "gluErrorString", "GLenum"); 3565 return(C_to_Xen_constchar_(gluErrorString(Xen_to_C_GLenum(error)))); 3566 } 3567 3568 static Xen gxg_gluGetNurbsProperty(Xen nurb, Xen property, Xen data) 3569 { 3570 #define H_gluGetNurbsProperty "void gluGetNurbsProperty(GLUnurbs* nurb, GLenum property, GLfloat* data)" 3571 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluGetNurbsProperty", "GLUnurbs*"); 3572 Xen_check_type(Xen_is_GLenum(property), property, 2, "gluGetNurbsProperty", "GLenum"); 3573 Xen_check_type(Xen_is_GLfloat_(data), data, 3, "gluGetNurbsProperty", "GLfloat*"); 3574 gluGetNurbsProperty(Xen_to_C_GLUnurbs_(nurb), Xen_to_C_GLenum(property), Xen_to_C_GLfloat_(data)); 3575 return(Xen_false); 3576 } 3577 3578 static Xen gxg_gluGetString(Xen name) 3579 { 3580 #define H_gluGetString "constchar* gluGetString(GLenum name)" 3581 Xen_check_type(Xen_is_GLenum(name), name, 1, "gluGetString", "GLenum"); 3582 return(C_to_Xen_constchar_(gluGetString(Xen_to_C_GLenum(name)))); 3583 } 3584 3585 #ifdef GLU_VERSION_1_2 3586 static Xen gxg_gluGetTessProperty(Xen tess, Xen which, Xen data) 3587 { 3588 #define H_gluGetTessProperty "void gluGetTessProperty(GLUtesselator* tess, GLenum which, GLdouble* data)" 3589 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluGetTessProperty", "GLUtesselator*"); 3590 Xen_check_type(Xen_is_GLenum(which), which, 2, "gluGetTessProperty", "GLenum"); 3591 Xen_check_type(Xen_is_GLdouble_(data), data, 3, "gluGetTessProperty", "GLdouble*"); 3592 gluGetTessProperty(Xen_to_C_GLUtesselator_(tess), Xen_to_C_GLenum(which), Xen_to_C_GLdouble_(data)); 3593 return(Xen_false); 3594 } 3595 #endif 3596 3597 static Xen gxg_gluLoadSamplingMatrices(Xen nurb, Xen model, Xen perspective, Xen view) 3598 { 3599 #define H_gluLoadSamplingMatrices "void gluLoadSamplingMatrices(GLUnurbs* nurb, GLfloat* model, GLfloat* perspective, \ 3600 GLint* view)" 3601 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluLoadSamplingMatrices", "GLUnurbs*"); 3602 Xen_check_type(Xen_is_GLfloat_(model), model, 2, "gluLoadSamplingMatrices", "GLfloat*"); 3603 Xen_check_type(Xen_is_GLfloat_(perspective), perspective, 3, "gluLoadSamplingMatrices", "GLfloat*"); 3604 Xen_check_type(Xen_is_GLint_(view), view, 4, "gluLoadSamplingMatrices", "GLint*"); 3605 gluLoadSamplingMatrices(Xen_to_C_GLUnurbs_(nurb), Xen_to_C_GLfloat_(model), Xen_to_C_GLfloat_(perspective), Xen_to_C_GLint_(view)); 3606 return(Xen_false); 3607 } 3608 3609 static Xen gxg_gluLookAt(Xen arglist) 3610 { 3611 #define H_gluLookAt "void gluLookAt(GLdouble eyeX, GLdouble eyeY, GLdouble eyeZ, GLdouble centerX, \ 3612 GLdouble centerY, GLdouble centerZ, GLdouble upX, GLdouble upY, GLdouble upZ)" 3613 Xen eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ; 3614 eyeX = Xen_list_ref(arglist, 0); 3615 eyeY = Xen_list_ref(arglist, 1); 3616 eyeZ = Xen_list_ref(arglist, 2); 3617 centerX = Xen_list_ref(arglist, 3); 3618 centerY = Xen_list_ref(arglist, 4); 3619 centerZ = Xen_list_ref(arglist, 5); 3620 upX = Xen_list_ref(arglist, 6); 3621 upY = Xen_list_ref(arglist, 7); 3622 upZ = Xen_list_ref(arglist, 8); 3623 Xen_check_type(Xen_is_GLdouble(eyeX), eyeX, 1, "gluLookAt", "GLdouble"); 3624 Xen_check_type(Xen_is_GLdouble(eyeY), eyeY, 2, "gluLookAt", "GLdouble"); 3625 Xen_check_type(Xen_is_GLdouble(eyeZ), eyeZ, 3, "gluLookAt", "GLdouble"); 3626 Xen_check_type(Xen_is_GLdouble(centerX), centerX, 4, "gluLookAt", "GLdouble"); 3627 Xen_check_type(Xen_is_GLdouble(centerY), centerY, 5, "gluLookAt", "GLdouble"); 3628 Xen_check_type(Xen_is_GLdouble(centerZ), centerZ, 6, "gluLookAt", "GLdouble"); 3629 Xen_check_type(Xen_is_GLdouble(upX), upX, 7, "gluLookAt", "GLdouble"); 3630 Xen_check_type(Xen_is_GLdouble(upY), upY, 8, "gluLookAt", "GLdouble"); 3631 Xen_check_type(Xen_is_GLdouble(upZ), upZ, 9, "gluLookAt", "GLdouble"); 3632 gluLookAt(Xen_to_C_GLdouble(eyeX), Xen_to_C_GLdouble(eyeY), Xen_to_C_GLdouble(eyeZ), Xen_to_C_GLdouble(centerX), Xen_to_C_GLdouble(centerY), 3633 Xen_to_C_GLdouble(centerZ), Xen_to_C_GLdouble(upX), Xen_to_C_GLdouble(upY), Xen_to_C_GLdouble(upZ)); 3634 return(Xen_false); 3635 } 3636 3637 static Xen gxg_gluNewNurbsRenderer(void) 3638 { 3639 #define H_gluNewNurbsRenderer "GLUnurbs* gluNewNurbsRenderer( void)" 3640 return(C_to_Xen_GLUnurbs_(gluNewNurbsRenderer())); 3641 } 3642 3643 static Xen gxg_gluNewQuadric(void) 3644 { 3645 #define H_gluNewQuadric "GLUquadric* gluNewQuadric( void)" 3646 return(C_to_Xen_GLUquadric_(gluNewQuadric())); 3647 } 3648 3649 #ifdef GLU_VERSION_1_2 3650 static Xen gxg_gluNewTess(void) 3651 { 3652 #define H_gluNewTess "GLUtesselator* gluNewTess( void)" 3653 return(C_to_Xen_GLUtesselator_(gluNewTess())); 3654 } 3655 #endif 3656 3657 #ifdef GLU_VERSION_1_2 3658 static Xen gxg_gluNextContour(Xen tess, Xen type) 3659 { 3660 #define H_gluNextContour "void gluNextContour(GLUtesselator* tess, GLenum type)" 3661 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluNextContour", "GLUtesselator*"); 3662 Xen_check_type(Xen_is_GLenum(type), type, 2, "gluNextContour", "GLenum"); 3663 gluNextContour(Xen_to_C_GLUtesselator_(tess), Xen_to_C_GLenum(type)); 3664 return(Xen_false); 3665 } 3666 #endif 3667 3668 static Xen gxg_gluNurbsCallback(Xen nurb, Xen which, Xen CallBackFunc) 3669 { 3670 #define H_gluNurbsCallback "void gluNurbsCallback(GLUnurbs* nurb, GLenum which, _GLUfuncptr CallBackFunc)" 3671 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluNurbsCallback", "GLUnurbs*"); 3672 Xen_check_type(Xen_is_GLenum(which), which, 2, "gluNurbsCallback", "GLenum"); 3673 Xen_check_type(Xen_is__GLUfuncptr(CallBackFunc), CallBackFunc, 3, "gluNurbsCallback", "_GLUfuncptr"); 3674 gluNurbsCallback(Xen_to_C_GLUnurbs_(nurb), Xen_to_C_GLenum(which), Xen_to_C__GLUfuncptr(CallBackFunc)); 3675 return(Xen_false); 3676 } 3677 3678 static Xen gxg_gluNurbsCallbackData(Xen nurb, Xen userData) 3679 { 3680 #define H_gluNurbsCallbackData "void gluNurbsCallbackData(GLUnurbs* nurb, GLvoid* userData)" 3681 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluNurbsCallbackData", "GLUnurbs*"); 3682 Xen_check_type(Xen_is_GLvoid_(userData), userData, 2, "gluNurbsCallbackData", "GLvoid*"); 3683 gluNurbsCallbackData(Xen_to_C_GLUnurbs_(nurb), Xen_to_C_GLvoid_(userData)); 3684 return(Xen_false); 3685 } 3686 3687 static Xen gxg_gluNurbsCurve(Xen nurb, Xen knotCount, Xen knots, Xen stride, Xen control, Xen order, Xen type) 3688 { 3689 #define H_gluNurbsCurve "void gluNurbsCurve(GLUnurbs* nurb, GLint knotCount, GLfloat* knots, GLint stride, \ 3690 GLfloat* control, GLint order, GLenum type)" 3691 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluNurbsCurve", "GLUnurbs*"); 3692 Xen_check_type(Xen_is_GLint(knotCount), knotCount, 2, "gluNurbsCurve", "GLint"); 3693 Xen_check_type(Xen_is_GLfloat_(knots), knots, 3, "gluNurbsCurve", "GLfloat*"); 3694 Xen_check_type(Xen_is_GLint(stride), stride, 4, "gluNurbsCurve", "GLint"); 3695 Xen_check_type(Xen_is_GLfloat_(control), control, 5, "gluNurbsCurve", "GLfloat*"); 3696 Xen_check_type(Xen_is_GLint(order), order, 6, "gluNurbsCurve", "GLint"); 3697 Xen_check_type(Xen_is_GLenum(type), type, 7, "gluNurbsCurve", "GLenum"); 3698 gluNurbsCurve(Xen_to_C_GLUnurbs_(nurb), Xen_to_C_GLint(knotCount), Xen_to_C_GLfloat_(knots), Xen_to_C_GLint(stride), Xen_to_C_GLfloat_(control), 3699 Xen_to_C_GLint(order), Xen_to_C_GLenum(type)); 3700 return(Xen_false); 3701 } 3702 3703 static Xen gxg_gluNurbsProperty(Xen nurb, Xen property, Xen value) 3704 { 3705 #define H_gluNurbsProperty "void gluNurbsProperty(GLUnurbs* nurb, GLenum property, GLfloat value)" 3706 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluNurbsProperty", "GLUnurbs*"); 3707 Xen_check_type(Xen_is_GLenum(property), property, 2, "gluNurbsProperty", "GLenum"); 3708 Xen_check_type(Xen_is_GLfloat(value), value, 3, "gluNurbsProperty", "GLfloat"); 3709 gluNurbsProperty(Xen_to_C_GLUnurbs_(nurb), Xen_to_C_GLenum(property), Xen_to_C_GLfloat(value)); 3710 return(Xen_false); 3711 } 3712 3713 static Xen gxg_gluNurbsSurface(Xen arglist) 3714 { 3715 #define H_gluNurbsSurface "void gluNurbsSurface(GLUnurbs* nurb, GLint sKnotCount, GLfloat* sKnots, \ 3716 GLint tKnotCount, GLfloat* tKnots, GLint sStride, GLint tStride, GLfloat* control, GLint sOrder, GLint tOrder, \ 3717 GLenum type)" 3718 Xen nurb, sKnotCount, sKnots, tKnotCount, tKnots, sStride, tStride, control, sOrder, tOrder, type; 3719 nurb = Xen_list_ref(arglist, 0); 3720 sKnotCount = Xen_list_ref(arglist, 1); 3721 sKnots = Xen_list_ref(arglist, 2); 3722 tKnotCount = Xen_list_ref(arglist, 3); 3723 tKnots = Xen_list_ref(arglist, 4); 3724 sStride = Xen_list_ref(arglist, 5); 3725 tStride = Xen_list_ref(arglist, 6); 3726 control = Xen_list_ref(arglist, 7); 3727 sOrder = Xen_list_ref(arglist, 8); 3728 tOrder = Xen_list_ref(arglist, 9); 3729 type = Xen_list_ref(arglist, 10); 3730 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluNurbsSurface", "GLUnurbs*"); 3731 Xen_check_type(Xen_is_GLint(sKnotCount), sKnotCount, 2, "gluNurbsSurface", "GLint"); 3732 Xen_check_type(Xen_is_GLfloat_(sKnots), sKnots, 3, "gluNurbsSurface", "GLfloat*"); 3733 Xen_check_type(Xen_is_GLint(tKnotCount), tKnotCount, 4, "gluNurbsSurface", "GLint"); 3734 Xen_check_type(Xen_is_GLfloat_(tKnots), tKnots, 5, "gluNurbsSurface", "GLfloat*"); 3735 Xen_check_type(Xen_is_GLint(sStride), sStride, 6, "gluNurbsSurface", "GLint"); 3736 Xen_check_type(Xen_is_GLint(tStride), tStride, 7, "gluNurbsSurface", "GLint"); 3737 Xen_check_type(Xen_is_GLfloat_(control), control, 8, "gluNurbsSurface", "GLfloat*"); 3738 Xen_check_type(Xen_is_GLint(sOrder), sOrder, 9, "gluNurbsSurface", "GLint"); 3739 Xen_check_type(Xen_is_GLint(tOrder), tOrder, 10, "gluNurbsSurface", "GLint"); 3740 Xen_check_type(Xen_is_GLenum(type), type, 11, "gluNurbsSurface", "GLenum"); 3741 gluNurbsSurface(Xen_to_C_GLUnurbs_(nurb), Xen_to_C_GLint(sKnotCount), Xen_to_C_GLfloat_(sKnots), Xen_to_C_GLint(tKnotCount), 3742 Xen_to_C_GLfloat_(tKnots), Xen_to_C_GLint(sStride), Xen_to_C_GLint(tStride), Xen_to_C_GLfloat_(control), 3743 Xen_to_C_GLint(sOrder), Xen_to_C_GLint(tOrder), Xen_to_C_GLenum(type)); 3744 return(Xen_false); 3745 } 3746 3747 static Xen gxg_gluOrtho2D(Xen left, Xen right, Xen bottom, Xen top) 3748 { 3749 #define H_gluOrtho2D "void gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top)" 3750 Xen_check_type(Xen_is_GLdouble(left), left, 1, "gluOrtho2D", "GLdouble"); 3751 Xen_check_type(Xen_is_GLdouble(right), right, 2, "gluOrtho2D", "GLdouble"); 3752 Xen_check_type(Xen_is_GLdouble(bottom), bottom, 3, "gluOrtho2D", "GLdouble"); 3753 Xen_check_type(Xen_is_GLdouble(top), top, 4, "gluOrtho2D", "GLdouble"); 3754 gluOrtho2D(Xen_to_C_GLdouble(left), Xen_to_C_GLdouble(right), Xen_to_C_GLdouble(bottom), Xen_to_C_GLdouble(top)); 3755 return(Xen_false); 3756 } 3757 3758 static Xen gxg_gluPartialDisk(Xen quad, Xen inner, Xen outer, Xen slices, Xen loops, Xen start, Xen sweep) 3759 { 3760 #define H_gluPartialDisk "void gluPartialDisk(GLUquadric* quad, GLdouble inner, GLdouble outer, GLint slices, \ 3761 GLint loops, GLdouble start, GLdouble sweep)" 3762 Xen_check_type(Xen_is_GLUquadric_(quad), quad, 1, "gluPartialDisk", "GLUquadric*"); 3763 Xen_check_type(Xen_is_GLdouble(inner), inner, 2, "gluPartialDisk", "GLdouble"); 3764 Xen_check_type(Xen_is_GLdouble(outer), outer, 3, "gluPartialDisk", "GLdouble"); 3765 Xen_check_type(Xen_is_GLint(slices), slices, 4, "gluPartialDisk", "GLint"); 3766 Xen_check_type(Xen_is_GLint(loops), loops, 5, "gluPartialDisk", "GLint"); 3767 Xen_check_type(Xen_is_GLdouble(start), start, 6, "gluPartialDisk", "GLdouble"); 3768 Xen_check_type(Xen_is_GLdouble(sweep), sweep, 7, "gluPartialDisk", "GLdouble"); 3769 gluPartialDisk(Xen_to_C_GLUquadric_(quad), Xen_to_C_GLdouble(inner), Xen_to_C_GLdouble(outer), Xen_to_C_GLint(slices), 3770 Xen_to_C_GLint(loops), Xen_to_C_GLdouble(start), Xen_to_C_GLdouble(sweep)); 3771 return(Xen_false); 3772 } 3773 3774 static Xen gxg_gluPerspective(Xen fovy, Xen aspect, Xen zNear, Xen zFar) 3775 { 3776 #define H_gluPerspective "void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)" 3777 Xen_check_type(Xen_is_GLdouble(fovy), fovy, 1, "gluPerspective", "GLdouble"); 3778 Xen_check_type(Xen_is_GLdouble(aspect), aspect, 2, "gluPerspective", "GLdouble"); 3779 Xen_check_type(Xen_is_GLdouble(zNear), zNear, 3, "gluPerspective", "GLdouble"); 3780 Xen_check_type(Xen_is_GLdouble(zFar), zFar, 4, "gluPerspective", "GLdouble"); 3781 gluPerspective(Xen_to_C_GLdouble(fovy), Xen_to_C_GLdouble(aspect), Xen_to_C_GLdouble(zNear), Xen_to_C_GLdouble(zFar)); 3782 return(Xen_false); 3783 } 3784 3785 static Xen gxg_gluPickMatrix(Xen x, Xen y, Xen delX, Xen delY, Xen viewport) 3786 { 3787 #define H_gluPickMatrix "void gluPickMatrix(GLdouble x, GLdouble y, GLdouble delX, GLdouble delY, GLint* viewport)" 3788 Xen_check_type(Xen_is_GLdouble(x), x, 1, "gluPickMatrix", "GLdouble"); 3789 Xen_check_type(Xen_is_GLdouble(y), y, 2, "gluPickMatrix", "GLdouble"); 3790 Xen_check_type(Xen_is_GLdouble(delX), delX, 3, "gluPickMatrix", "GLdouble"); 3791 Xen_check_type(Xen_is_GLdouble(delY), delY, 4, "gluPickMatrix", "GLdouble"); 3792 Xen_check_type(Xen_is_GLint_(viewport), viewport, 5, "gluPickMatrix", "GLint*"); 3793 gluPickMatrix(Xen_to_C_GLdouble(x), Xen_to_C_GLdouble(y), Xen_to_C_GLdouble(delX), Xen_to_C_GLdouble(delY), Xen_to_C_GLint_(viewport)); 3794 return(Xen_false); 3795 } 3796 3797 static Xen gxg_gluProject(Xen arglist) 3798 { 3799 #define H_gluProject "GLint gluProject(GLdouble objX, GLdouble objY, GLdouble objZ, GLdouble* model, \ 3800 GLdouble* proj, GLint* view, GLdouble* [winX], GLdouble* [winY], GLdouble* [winZ])" 3801 GLdouble ref_winX[1]; 3802 GLdouble ref_winY[1]; 3803 GLdouble ref_winZ[1]; 3804 Xen objX, objY, objZ, model, proj, view; 3805 objX = Xen_list_ref(arglist, 0); 3806 objY = Xen_list_ref(arglist, 1); 3807 objZ = Xen_list_ref(arglist, 2); 3808 model = Xen_list_ref(arglist, 3); 3809 proj = Xen_list_ref(arglist, 4); 3810 view = Xen_list_ref(arglist, 5); 3811 Xen_check_type(Xen_is_GLdouble(objX), objX, 1, "gluProject", "GLdouble"); 3812 Xen_check_type(Xen_is_GLdouble(objY), objY, 2, "gluProject", "GLdouble"); 3813 Xen_check_type(Xen_is_GLdouble(objZ), objZ, 3, "gluProject", "GLdouble"); 3814 Xen_check_type(Xen_is_GLdouble_(model), model, 4, "gluProject", "GLdouble*"); 3815 Xen_check_type(Xen_is_GLdouble_(proj), proj, 5, "gluProject", "GLdouble*"); 3816 Xen_check_type(Xen_is_GLint_(view), view, 6, "gluProject", "GLint*"); 3817 { 3818 Xen result; 3819 result = C_to_Xen_GLint(gluProject(Xen_to_C_GLdouble(objX), Xen_to_C_GLdouble(objY), Xen_to_C_GLdouble(objZ), Xen_to_C_GLdouble_(model), 3820 Xen_to_C_GLdouble_(proj), Xen_to_C_GLint_(view), ref_winX, ref_winY, ref_winZ)); 3821 return(Xen_list_4(result, C_to_Xen_GLdouble(ref_winX[0]), C_to_Xen_GLdouble(ref_winY[0]), C_to_Xen_GLdouble(ref_winZ[0]))); 3822 } 3823 } 3824 3825 static Xen gxg_gluPwlCurve(Xen nurb, Xen count, Xen data, Xen stride, Xen type) 3826 { 3827 #define H_gluPwlCurve "void gluPwlCurve(GLUnurbs* nurb, GLint count, GLfloat* data, GLint stride, GLenum type)" 3828 Xen_check_type(Xen_is_GLUnurbs_(nurb), nurb, 1, "gluPwlCurve", "GLUnurbs*"); 3829 Xen_check_type(Xen_is_GLint(count), count, 2, "gluPwlCurve", "GLint"); 3830 Xen_check_type(Xen_is_GLfloat_(data), data, 3, "gluPwlCurve", "GLfloat*"); 3831 Xen_check_type(Xen_is_GLint(stride), stride, 4, "gluPwlCurve", "GLint"); 3832 Xen_check_type(Xen_is_GLenum(type), type, 5, "gluPwlCurve", "GLenum"); 3833 gluPwlCurve(Xen_to_C_GLUnurbs_(nurb), Xen_to_C_GLint(count), Xen_to_C_GLfloat_(data), Xen_to_C_GLint(stride), Xen_to_C_GLenum(type)); 3834 return(Xen_false); 3835 } 3836 3837 static Xen gxg_gluQuadricCallback(Xen quad, Xen which, Xen CallBackFunc) 3838 { 3839 #define H_gluQuadricCallback "void gluQuadricCallback(GLUquadric* quad, GLenum which, _GLUfuncptr CallBackFunc)" 3840 Xen_check_type(Xen_is_GLUquadric_(quad), quad, 1, "gluQuadricCallback", "GLUquadric*"); 3841 Xen_check_type(Xen_is_GLenum(which), which, 2, "gluQuadricCallback", "GLenum"); 3842 Xen_check_type(Xen_is__GLUfuncptr(CallBackFunc), CallBackFunc, 3, "gluQuadricCallback", "_GLUfuncptr"); 3843 gluQuadricCallback(Xen_to_C_GLUquadric_(quad), Xen_to_C_GLenum(which), Xen_to_C__GLUfuncptr(CallBackFunc)); 3844 return(Xen_false); 3845 } 3846 3847 static Xen gxg_gluQuadricDrawStyle(Xen quad, Xen draw) 3848 { 3849 #define H_gluQuadricDrawStyle "void gluQuadricDrawStyle(GLUquadric* quad, GLenum draw)" 3850 Xen_check_type(Xen_is_GLUquadric_(quad), quad, 1, "gluQuadricDrawStyle", "GLUquadric*"); 3851 Xen_check_type(Xen_is_GLenum(draw), draw, 2, "gluQuadricDrawStyle", "GLenum"); 3852 gluQuadricDrawStyle(Xen_to_C_GLUquadric_(quad), Xen_to_C_GLenum(draw)); 3853 return(Xen_false); 3854 } 3855 3856 static Xen gxg_gluQuadricNormals(Xen quad, Xen normal) 3857 { 3858 #define H_gluQuadricNormals "void gluQuadricNormals(GLUquadric* quad, GLenum normal)" 3859 Xen_check_type(Xen_is_GLUquadric_(quad), quad, 1, "gluQuadricNormals", "GLUquadric*"); 3860 Xen_check_type(Xen_is_GLenum(normal), normal, 2, "gluQuadricNormals", "GLenum"); 3861 gluQuadricNormals(Xen_to_C_GLUquadric_(quad), Xen_to_C_GLenum(normal)); 3862 return(Xen_false); 3863 } 3864 3865 static Xen gxg_gluQuadricOrientation(Xen quad, Xen orientation) 3866 { 3867 #define H_gluQuadricOrientation "void gluQuadricOrientation(GLUquadric* quad, GLenum orientation)" 3868 Xen_check_type(Xen_is_GLUquadric_(quad), quad, 1, "gluQuadricOrientation", "GLUquadric*"); 3869 Xen_check_type(Xen_is_GLenum(orientation), orientation, 2, "gluQuadricOrientation", "GLenum"); 3870 gluQuadricOrientation(Xen_to_C_GLUquadric_(quad), Xen_to_C_GLenum(orientation)); 3871 return(Xen_false); 3872 } 3873 3874 static Xen gxg_gluQuadricTexture(Xen quad, Xen texture) 3875 { 3876 #define H_gluQuadricTexture "void gluQuadricTexture(GLUquadric* quad, GLboolean texture)" 3877 Xen_check_type(Xen_is_GLUquadric_(quad), quad, 1, "gluQuadricTexture", "GLUquadric*"); 3878 Xen_check_type(Xen_is_GLboolean(texture), texture, 2, "gluQuadricTexture", "GLboolean"); 3879 gluQuadricTexture(Xen_to_C_GLUquadric_(quad), Xen_to_C_GLboolean(texture)); 3880 return(Xen_false); 3881 } 3882 3883 static Xen gxg_gluScaleImage(Xen arglist) 3884 { 3885 #define H_gluScaleImage "GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, \ 3886 void* dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid* dataOut)" 3887 Xen format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut; 3888 format = Xen_list_ref(arglist, 0); 3889 wIn = Xen_list_ref(arglist, 1); 3890 hIn = Xen_list_ref(arglist, 2); 3891 typeIn = Xen_list_ref(arglist, 3); 3892 dataIn = Xen_list_ref(arglist, 4); 3893 wOut = Xen_list_ref(arglist, 5); 3894 hOut = Xen_list_ref(arglist, 6); 3895 typeOut = Xen_list_ref(arglist, 7); 3896 dataOut = Xen_list_ref(arglist, 8); 3897 Xen_check_type(Xen_is_GLenum(format), format, 1, "gluScaleImage", "GLenum"); 3898 Xen_check_type(Xen_is_GLsizei(wIn), wIn, 2, "gluScaleImage", "GLsizei"); 3899 Xen_check_type(Xen_is_GLsizei(hIn), hIn, 3, "gluScaleImage", "GLsizei"); 3900 Xen_check_type(Xen_is_GLenum(typeIn), typeIn, 4, "gluScaleImage", "GLenum"); 3901 Xen_check_type(Xen_is_void_(dataIn), dataIn, 5, "gluScaleImage", "void*"); 3902 Xen_check_type(Xen_is_GLsizei(wOut), wOut, 6, "gluScaleImage", "GLsizei"); 3903 Xen_check_type(Xen_is_GLsizei(hOut), hOut, 7, "gluScaleImage", "GLsizei"); 3904 Xen_check_type(Xen_is_GLenum(typeOut), typeOut, 8, "gluScaleImage", "GLenum"); 3905 Xen_check_type(Xen_is_GLvoid_(dataOut), dataOut, 9, "gluScaleImage", "GLvoid*"); 3906 return(C_to_Xen_GLint(gluScaleImage(Xen_to_C_GLenum(format), Xen_to_C_GLsizei(wIn), Xen_to_C_GLsizei(hIn), Xen_to_C_GLenum(typeIn), 3907 Xen_to_C_void_(dataIn), Xen_to_C_GLsizei(wOut), Xen_to_C_GLsizei(hOut), Xen_to_C_GLenum(typeOut), 3908 Xen_to_C_GLvoid_(dataOut)))); 3909 } 3910 3911 static Xen gxg_gluSphere(Xen quad, Xen radius, Xen slices, Xen stacks) 3912 { 3913 #define H_gluSphere "void gluSphere(GLUquadric* quad, GLdouble radius, GLint slices, GLint stacks)" 3914 Xen_check_type(Xen_is_GLUquadric_(quad), quad, 1, "gluSphere", "GLUquadric*"); 3915 Xen_check_type(Xen_is_GLdouble(radius), radius, 2, "gluSphere", "GLdouble"); 3916 Xen_check_type(Xen_is_GLint(slices), slices, 3, "gluSphere", "GLint"); 3917 Xen_check_type(Xen_is_GLint(stacks), stacks, 4, "gluSphere", "GLint"); 3918 gluSphere(Xen_to_C_GLUquadric_(quad), Xen_to_C_GLdouble(radius), Xen_to_C_GLint(slices), Xen_to_C_GLint(stacks)); 3919 return(Xen_false); 3920 } 3921 3922 #ifdef GLU_VERSION_1_2 3923 static Xen gxg_gluTessBeginContour(Xen tess) 3924 { 3925 #define H_gluTessBeginContour "void gluTessBeginContour(GLUtesselator* tess)" 3926 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluTessBeginContour", "GLUtesselator*"); 3927 gluTessBeginContour(Xen_to_C_GLUtesselator_(tess)); 3928 return(Xen_false); 3929 } 3930 #endif 3931 3932 #ifdef GLU_VERSION_1_2 3933 static Xen gxg_gluTessBeginPolygon(Xen tess, Xen data) 3934 { 3935 #define H_gluTessBeginPolygon "void gluTessBeginPolygon(GLUtesselator* tess, GLvoid* data)" 3936 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluTessBeginPolygon", "GLUtesselator*"); 3937 Xen_check_type(Xen_is_GLvoid_(data), data, 2, "gluTessBeginPolygon", "GLvoid*"); 3938 gluTessBeginPolygon(Xen_to_C_GLUtesselator_(tess), Xen_to_C_GLvoid_(data)); 3939 return(Xen_false); 3940 } 3941 #endif 3942 3943 static Xen gxg_gluTessCallback(Xen tess, Xen which, Xen CallBackFunc) 3944 { 3945 #define H_gluTessCallback "void gluTessCallback(GLUtesselator* tess, GLenum which, _GLUfuncptr CallBackFunc)" 3946 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluTessCallback", "GLUtesselator*"); 3947 Xen_check_type(Xen_is_GLenum(which), which, 2, "gluTessCallback", "GLenum"); 3948 Xen_check_type(Xen_is__GLUfuncptr(CallBackFunc), CallBackFunc, 3, "gluTessCallback", "_GLUfuncptr"); 3949 gluTessCallback(Xen_to_C_GLUtesselator_(tess), Xen_to_C_GLenum(which), Xen_to_C__GLUfuncptr(CallBackFunc)); 3950 return(Xen_false); 3951 } 3952 3953 #ifdef GLU_VERSION_1_2 3954 static Xen gxg_gluTessEndContour(Xen tess) 3955 { 3956 #define H_gluTessEndContour "void gluTessEndContour(GLUtesselator* tess)" 3957 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluTessEndContour", "GLUtesselator*"); 3958 gluTessEndContour(Xen_to_C_GLUtesselator_(tess)); 3959 return(Xen_false); 3960 } 3961 #endif 3962 3963 #ifdef GLU_VERSION_1_2 3964 static Xen gxg_gluTessEndPolygon(Xen tess) 3965 { 3966 #define H_gluTessEndPolygon "void gluTessEndPolygon(GLUtesselator* tess)" 3967 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluTessEndPolygon", "GLUtesselator*"); 3968 gluTessEndPolygon(Xen_to_C_GLUtesselator_(tess)); 3969 return(Xen_false); 3970 } 3971 #endif 3972 3973 #ifdef GLU_VERSION_1_2 3974 static Xen gxg_gluTessNormal(Xen tess, Xen valueX, Xen valueY, Xen valueZ) 3975 { 3976 #define H_gluTessNormal "void gluTessNormal(GLUtesselator* tess, GLdouble valueX, GLdouble valueY, \ 3977 GLdouble valueZ)" 3978 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluTessNormal", "GLUtesselator*"); 3979 Xen_check_type(Xen_is_GLdouble(valueX), valueX, 2, "gluTessNormal", "GLdouble"); 3980 Xen_check_type(Xen_is_GLdouble(valueY), valueY, 3, "gluTessNormal", "GLdouble"); 3981 Xen_check_type(Xen_is_GLdouble(valueZ), valueZ, 4, "gluTessNormal", "GLdouble"); 3982 gluTessNormal(Xen_to_C_GLUtesselator_(tess), Xen_to_C_GLdouble(valueX), Xen_to_C_GLdouble(valueY), Xen_to_C_GLdouble(valueZ)); 3983 return(Xen_false); 3984 } 3985 #endif 3986 3987 #ifdef GLU_VERSION_1_2 3988 static Xen gxg_gluTessProperty(Xen tess, Xen which, Xen data) 3989 { 3990 #define H_gluTessProperty "void gluTessProperty(GLUtesselator* tess, GLenum which, GLdouble data)" 3991 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluTessProperty", "GLUtesselator*"); 3992 Xen_check_type(Xen_is_GLenum(which), which, 2, "gluTessProperty", "GLenum"); 3993 Xen_check_type(Xen_is_GLdouble(data), data, 3, "gluTessProperty", "GLdouble"); 3994 gluTessProperty(Xen_to_C_GLUtesselator_(tess), Xen_to_C_GLenum(which), Xen_to_C_GLdouble(data)); 3995 return(Xen_false); 3996 } 3997 #endif 3998 3999 #ifdef GLU_VERSION_1_2 4000 static Xen gxg_gluTessVertex(Xen tess, Xen location, Xen data) 4001 { 4002 #define H_gluTessVertex "void gluTessVertex(GLUtesselator* tess, GLdouble* location, GLvoid* data)" 4003 Xen_check_type(Xen_is_GLUtesselator_(tess), tess, 1, "gluTessVertex", "GLUtesselator*"); 4004 Xen_check_type(Xen_is_GLdouble_(location), location, 2, "gluTessVertex", "GLdouble*"); 4005 Xen_check_type(Xen_is_GLvoid_(data), data, 3, "gluTessVertex", "GLvoid*"); 4006 gluTessVertex(Xen_to_C_GLUtesselator_(tess), Xen_to_C_GLdouble_(location), Xen_to_C_GLvoid_(data)); 4007 return(Xen_false); 4008 } 4009 #endif 4010 4011 static Xen gxg_gluUnProject(Xen arglist) 4012 { 4013 #define H_gluUnProject "GLint gluUnProject(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble* model, \ 4014 GLdouble* proj, GLint* view, GLdouble* [objX], GLdouble* [objY], GLdouble* [objZ])" 4015 GLdouble ref_objX[1]; 4016 GLdouble ref_objY[1]; 4017 GLdouble ref_objZ[1]; 4018 Xen winX, winY, winZ, model, proj, view; 4019 winX = Xen_list_ref(arglist, 0); 4020 winY = Xen_list_ref(arglist, 1); 4021 winZ = Xen_list_ref(arglist, 2); 4022 model = Xen_list_ref(arglist, 3); 4023 proj = Xen_list_ref(arglist, 4); 4024 view = Xen_list_ref(arglist, 5); 4025 Xen_check_type(Xen_is_GLdouble(winX), winX, 1, "gluUnProject", "GLdouble"); 4026 Xen_check_type(Xen_is_GLdouble(winY), winY, 2, "gluUnProject", "GLdouble"); 4027 Xen_check_type(Xen_is_GLdouble(winZ), winZ, 3, "gluUnProject", "GLdouble"); 4028 Xen_check_type(Xen_is_GLdouble_(model), model, 4, "gluUnProject", "GLdouble*"); 4029 Xen_check_type(Xen_is_GLdouble_(proj), proj, 5, "gluUnProject", "GLdouble*"); 4030 Xen_check_type(Xen_is_GLint_(view), view, 6, "gluUnProject", "GLint*"); 4031 { 4032 Xen result; 4033 result = C_to_Xen_GLint(gluUnProject(Xen_to_C_GLdouble(winX), Xen_to_C_GLdouble(winY), Xen_to_C_GLdouble(winZ), Xen_to_C_GLdouble_(model), 4034 Xen_to_C_GLdouble_(proj), Xen_to_C_GLint_(view), ref_objX, ref_objY, ref_objZ)); 4035 return(Xen_list_4(result, C_to_Xen_GLdouble(ref_objX[0]), C_to_Xen_GLdouble(ref_objY[0]), C_to_Xen_GLdouble(ref_objZ[0]))); 4036 } 4037 } 4038 4039 static Xen gxg_gluUnProject4(Xen arglist) 4040 { 4041 #define H_gluUnProject4 "GLint gluUnProject4(GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, \ 4042 GLdouble* model, GLdouble* proj, GLint* view, GLdouble near, GLdouble far, GLdouble* [objX], GLdouble* [objY], \ 4043 GLdouble* [objZ], GLdouble* [objW])" 4044 GLdouble ref_objX[1]; 4045 GLdouble ref_objY[1]; 4046 GLdouble ref_objZ[1]; 4047 GLdouble ref_objW[1]; 4048 Xen winX, winY, winZ, clipW, model, proj, view, near, far; 4049 winX = Xen_list_ref(arglist, 0); 4050 winY = Xen_list_ref(arglist, 1); 4051 winZ = Xen_list_ref(arglist, 2); 4052 clipW = Xen_list_ref(arglist, 3); 4053 model = Xen_list_ref(arglist, 4); 4054 proj = Xen_list_ref(arglist, 5); 4055 view = Xen_list_ref(arglist, 6); 4056 near = Xen_list_ref(arglist, 7); 4057 far = Xen_list_ref(arglist, 8); 4058 Xen_check_type(Xen_is_GLdouble(winX), winX, 1, "gluUnProject4", "GLdouble"); 4059 Xen_check_type(Xen_is_GLdouble(winY), winY, 2, "gluUnProject4", "GLdouble"); 4060 Xen_check_type(Xen_is_GLdouble(winZ), winZ, 3, "gluUnProject4", "GLdouble"); 4061 Xen_check_type(Xen_is_GLdouble(clipW), clipW, 4, "gluUnProject4", "GLdouble"); 4062 Xen_check_type(Xen_is_GLdouble_(model), model, 5, "gluUnProject4", "GLdouble*"); 4063 Xen_check_type(Xen_is_GLdouble_(proj), proj, 6, "gluUnProject4", "GLdouble*"); 4064 Xen_check_type(Xen_is_GLint_(view), view, 7, "gluUnProject4", "GLint*"); 4065 Xen_check_type(Xen_is_GLdouble(near), near, 8, "gluUnProject4", "GLdouble"); 4066 Xen_check_type(Xen_is_GLdouble(far), far, 9, "gluUnProject4", "GLdouble"); 4067 { 4068 Xen result; 4069 result = C_to_Xen_GLint(gluUnProject4(Xen_to_C_GLdouble(winX), Xen_to_C_GLdouble(winY), Xen_to_C_GLdouble(winZ), Xen_to_C_GLdouble(clipW), 4070 Xen_to_C_GLdouble_(model), Xen_to_C_GLdouble_(proj), Xen_to_C_GLint_(view), Xen_to_C_GLdouble(near), 4071 Xen_to_C_GLdouble(far), ref_objX, ref_objY, ref_objZ, ref_objW)); 4072 return(Xen_list_5(result, C_to_Xen_GLdouble(ref_objX[0]), C_to_Xen_GLdouble(ref_objY[0]), C_to_Xen_GLdouble(ref_objZ[0]), C_to_Xen_GLdouble(ref_objW[0]))); 4073 } 4074 } 4075 4076 #endif 4077 #if USE_MOTIF 4078 Xen_wrap_3_args(gxg_glXChooseVisual_w, gxg_glXChooseVisual) 4079 Xen_wrap_4_args(gxg_glXCopyContext_w, gxg_glXCopyContext) 4080 Xen_wrap_4_args(gxg_glXCreateContext_w, gxg_glXCreateContext) 4081 Xen_wrap_3_args(gxg_glXCreateGLXPixmap_w, gxg_glXCreateGLXPixmap) 4082 Xen_wrap_2_args(gxg_glXDestroyContext_w, gxg_glXDestroyContext) 4083 Xen_wrap_2_args(gxg_glXDestroyGLXPixmap_w, gxg_glXDestroyGLXPixmap) 4084 Xen_wrap_4_optional_args(gxg_glXGetConfig_w, gxg_glXGetConfig) 4085 Xen_wrap_no_args(gxg_glXGetCurrentContext_w, gxg_glXGetCurrentContext) 4086 Xen_wrap_no_args(gxg_glXGetCurrentDrawable_w, gxg_glXGetCurrentDrawable) 4087 Xen_wrap_2_args(gxg_glXIsDirect_w, gxg_glXIsDirect) 4088 Xen_wrap_3_args(gxg_glXMakeCurrent_w, gxg_glXMakeCurrent) 4089 Xen_wrap_3_optional_args(gxg_glXQueryExtension_w, gxg_glXQueryExtension) 4090 Xen_wrap_3_optional_args(gxg_glXQueryVersion_w, gxg_glXQueryVersion) 4091 Xen_wrap_2_args(gxg_glXSwapBuffers_w, gxg_glXSwapBuffers) 4092 Xen_wrap_4_args(gxg_glXUseXFont_w, gxg_glXUseXFont) 4093 Xen_wrap_no_args(gxg_glXWaitGL_w, gxg_glXWaitGL) 4094 Xen_wrap_no_args(gxg_glXWaitX_w, gxg_glXWaitX) 4095 Xen_wrap_2_args(gxg_glXGetClientString_w, gxg_glXGetClientString) 4096 Xen_wrap_3_args(gxg_glXQueryServerString_w, gxg_glXQueryServerString) 4097 Xen_wrap_2_args(gxg_glXQueryExtensionsString_w, gxg_glXQueryExtensionsString) 4098 #endif 4099 Xen_wrap_1_arg(gxg_glClearIndex_w, gxg_glClearIndex) 4100 Xen_wrap_4_args(gxg_glClearColor_w, gxg_glClearColor) 4101 Xen_wrap_1_arg(gxg_glClear_w, gxg_glClear) 4102 Xen_wrap_1_arg(gxg_glIndexMask_w, gxg_glIndexMask) 4103 Xen_wrap_4_args(gxg_glColorMask_w, gxg_glColorMask) 4104 Xen_wrap_2_args(gxg_glAlphaFunc_w, gxg_glAlphaFunc) 4105 Xen_wrap_2_args(gxg_glBlendFunc_w, gxg_glBlendFunc) 4106 Xen_wrap_1_arg(gxg_glLogicOp_w, gxg_glLogicOp) 4107 Xen_wrap_1_arg(gxg_glCullFace_w, gxg_glCullFace) 4108 Xen_wrap_1_arg(gxg_glFrontFace_w, gxg_glFrontFace) 4109 Xen_wrap_1_arg(gxg_glPointSize_w, gxg_glPointSize) 4110 Xen_wrap_1_arg(gxg_glLineWidth_w, gxg_glLineWidth) 4111 Xen_wrap_2_args(gxg_glLineStipple_w, gxg_glLineStipple) 4112 Xen_wrap_2_args(gxg_glPolygonMode_w, gxg_glPolygonMode) 4113 Xen_wrap_2_args(gxg_glPolygonOffset_w, gxg_glPolygonOffset) 4114 Xen_wrap_1_arg(gxg_glPolygonStipple_w, gxg_glPolygonStipple) 4115 Xen_wrap_1_arg(gxg_glEdgeFlag_w, gxg_glEdgeFlag) 4116 Xen_wrap_4_args(gxg_glScissor_w, gxg_glScissor) 4117 Xen_wrap_2_args(gxg_glClipPlane_w, gxg_glClipPlane) 4118 Xen_wrap_2_optional_args(gxg_glGetClipPlane_w, gxg_glGetClipPlane) 4119 Xen_wrap_1_arg(gxg_glDrawBuffer_w, gxg_glDrawBuffer) 4120 Xen_wrap_1_arg(gxg_glReadBuffer_w, gxg_glReadBuffer) 4121 Xen_wrap_1_arg(gxg_glEnable_w, gxg_glEnable) 4122 Xen_wrap_1_arg(gxg_glDisable_w, gxg_glDisable) 4123 Xen_wrap_1_arg(gxg_glIsEnabled_w, gxg_glIsEnabled) 4124 Xen_wrap_1_arg(gxg_glEnableClientState_w, gxg_glEnableClientState) 4125 Xen_wrap_1_arg(gxg_glDisableClientState_w, gxg_glDisableClientState) 4126 Xen_wrap_2_optional_args(gxg_glGetBooleanv_w, gxg_glGetBooleanv) 4127 Xen_wrap_2_optional_args(gxg_glGetDoublev_w, gxg_glGetDoublev) 4128 Xen_wrap_2_optional_args(gxg_glGetFloatv_w, gxg_glGetFloatv) 4129 Xen_wrap_2_optional_args(gxg_glGetIntegerv_w, gxg_glGetIntegerv) 4130 Xen_wrap_1_arg(gxg_glPushAttrib_w, gxg_glPushAttrib) 4131 Xen_wrap_no_args(gxg_glPopAttrib_w, gxg_glPopAttrib) 4132 Xen_wrap_1_arg(gxg_glPushClientAttrib_w, gxg_glPushClientAttrib) 4133 Xen_wrap_no_args(gxg_glPopClientAttrib_w, gxg_glPopClientAttrib) 4134 Xen_wrap_1_arg(gxg_glRenderMode_w, gxg_glRenderMode) 4135 Xen_wrap_no_args(gxg_glGetError_w, gxg_glGetError) 4136 Xen_wrap_1_arg(gxg_glGetString_w, gxg_glGetString) 4137 Xen_wrap_no_args(gxg_glFinish_w, gxg_glFinish) 4138 Xen_wrap_no_args(gxg_glFlush_w, gxg_glFlush) 4139 Xen_wrap_2_args(gxg_glHint_w, gxg_glHint) 4140 Xen_wrap_1_arg(gxg_glClearDepth_w, gxg_glClearDepth) 4141 Xen_wrap_1_arg(gxg_glDepthFunc_w, gxg_glDepthFunc) 4142 Xen_wrap_1_arg(gxg_glDepthMask_w, gxg_glDepthMask) 4143 Xen_wrap_2_args(gxg_glDepthRange_w, gxg_glDepthRange) 4144 Xen_wrap_4_args(gxg_glClearAccum_w, gxg_glClearAccum) 4145 Xen_wrap_2_args(gxg_glAccum_w, gxg_glAccum) 4146 Xen_wrap_1_arg(gxg_glMatrixMode_w, gxg_glMatrixMode) 4147 Xen_wrap_6_args(gxg_glOrtho_w, gxg_glOrtho) 4148 Xen_wrap_6_args(gxg_glFrustum_w, gxg_glFrustum) 4149 Xen_wrap_4_args(gxg_glViewport_w, gxg_glViewport) 4150 Xen_wrap_no_args(gxg_glPushMatrix_w, gxg_glPushMatrix) 4151 Xen_wrap_no_args(gxg_glPopMatrix_w, gxg_glPopMatrix) 4152 Xen_wrap_no_args(gxg_glLoadIdentity_w, gxg_glLoadIdentity) 4153 Xen_wrap_1_arg(gxg_glLoadMatrixd_w, gxg_glLoadMatrixd) 4154 Xen_wrap_1_arg(gxg_glLoadMatrixf_w, gxg_glLoadMatrixf) 4155 Xen_wrap_1_arg(gxg_glMultMatrixd_w, gxg_glMultMatrixd) 4156 Xen_wrap_1_arg(gxg_glMultMatrixf_w, gxg_glMultMatrixf) 4157 Xen_wrap_4_args(gxg_glRotated_w, gxg_glRotated) 4158 Xen_wrap_4_args(gxg_glRotatef_w, gxg_glRotatef) 4159 Xen_wrap_3_args(gxg_glScaled_w, gxg_glScaled) 4160 Xen_wrap_3_args(gxg_glScalef_w, gxg_glScalef) 4161 Xen_wrap_3_args(gxg_glTranslated_w, gxg_glTranslated) 4162 Xen_wrap_3_args(gxg_glTranslatef_w, gxg_glTranslatef) 4163 Xen_wrap_1_arg(gxg_glIsList_w, gxg_glIsList) 4164 Xen_wrap_2_args(gxg_glDeleteLists_w, gxg_glDeleteLists) 4165 Xen_wrap_1_arg(gxg_glGenLists_w, gxg_glGenLists) 4166 Xen_wrap_2_args(gxg_glNewList_w, gxg_glNewList) 4167 Xen_wrap_no_args(gxg_glEndList_w, gxg_glEndList) 4168 Xen_wrap_1_arg(gxg_glCallList_w, gxg_glCallList) 4169 Xen_wrap_3_args(gxg_glCallLists_w, gxg_glCallLists) 4170 Xen_wrap_1_arg(gxg_glListBase_w, gxg_glListBase) 4171 Xen_wrap_1_arg(gxg_glBegin_w, gxg_glBegin) 4172 Xen_wrap_no_args(gxg_glEnd_w, gxg_glEnd) 4173 Xen_wrap_2_args(gxg_glVertex2d_w, gxg_glVertex2d) 4174 Xen_wrap_2_args(gxg_glVertex2f_w, gxg_glVertex2f) 4175 Xen_wrap_2_args(gxg_glVertex2i_w, gxg_glVertex2i) 4176 Xen_wrap_2_args(gxg_glVertex2s_w, gxg_glVertex2s) 4177 Xen_wrap_3_args(gxg_glVertex3d_w, gxg_glVertex3d) 4178 Xen_wrap_3_args(gxg_glVertex3f_w, gxg_glVertex3f) 4179 Xen_wrap_3_args(gxg_glVertex3i_w, gxg_glVertex3i) 4180 Xen_wrap_3_args(gxg_glVertex3s_w, gxg_glVertex3s) 4181 Xen_wrap_4_args(gxg_glVertex4d_w, gxg_glVertex4d) 4182 Xen_wrap_4_args(gxg_glVertex4f_w, gxg_glVertex4f) 4183 Xen_wrap_4_args(gxg_glVertex4i_w, gxg_glVertex4i) 4184 Xen_wrap_4_args(gxg_glVertex4s_w, gxg_glVertex4s) 4185 Xen_wrap_3_args(gxg_glNormal3b_w, gxg_glNormal3b) 4186 Xen_wrap_3_args(gxg_glNormal3d_w, gxg_glNormal3d) 4187 Xen_wrap_3_args(gxg_glNormal3f_w, gxg_glNormal3f) 4188 Xen_wrap_3_args(gxg_glNormal3i_w, gxg_glNormal3i) 4189 Xen_wrap_3_args(gxg_glNormal3s_w, gxg_glNormal3s) 4190 Xen_wrap_1_arg(gxg_glIndexd_w, gxg_glIndexd) 4191 Xen_wrap_1_arg(gxg_glIndexf_w, gxg_glIndexf) 4192 Xen_wrap_1_arg(gxg_glIndexi_w, gxg_glIndexi) 4193 Xen_wrap_1_arg(gxg_glIndexs_w, gxg_glIndexs) 4194 Xen_wrap_1_arg(gxg_glIndexub_w, gxg_glIndexub) 4195 Xen_wrap_3_args(gxg_glColor3b_w, gxg_glColor3b) 4196 Xen_wrap_3_args(gxg_glColor3d_w, gxg_glColor3d) 4197 Xen_wrap_3_args(gxg_glColor3f_w, gxg_glColor3f) 4198 Xen_wrap_3_args(gxg_glColor3i_w, gxg_glColor3i) 4199 Xen_wrap_3_args(gxg_glColor3s_w, gxg_glColor3s) 4200 Xen_wrap_3_args(gxg_glColor3ub_w, gxg_glColor3ub) 4201 Xen_wrap_3_args(gxg_glColor3ui_w, gxg_glColor3ui) 4202 Xen_wrap_3_args(gxg_glColor3us_w, gxg_glColor3us) 4203 Xen_wrap_4_args(gxg_glColor4b_w, gxg_glColor4b) 4204 Xen_wrap_4_args(gxg_glColor4d_w, gxg_glColor4d) 4205 Xen_wrap_4_args(gxg_glColor4f_w, gxg_glColor4f) 4206 Xen_wrap_4_args(gxg_glColor4i_w, gxg_glColor4i) 4207 Xen_wrap_4_args(gxg_glColor4s_w, gxg_glColor4s) 4208 Xen_wrap_4_args(gxg_glColor4ub_w, gxg_glColor4ub) 4209 Xen_wrap_4_args(gxg_glColor4ui_w, gxg_glColor4ui) 4210 Xen_wrap_4_args(gxg_glColor4us_w, gxg_glColor4us) 4211 Xen_wrap_1_arg(gxg_glTexCoord1d_w, gxg_glTexCoord1d) 4212 Xen_wrap_1_arg(gxg_glTexCoord1f_w, gxg_glTexCoord1f) 4213 Xen_wrap_1_arg(gxg_glTexCoord1i_w, gxg_glTexCoord1i) 4214 Xen_wrap_1_arg(gxg_glTexCoord1s_w, gxg_glTexCoord1s) 4215 Xen_wrap_2_args(gxg_glTexCoord2d_w, gxg_glTexCoord2d) 4216 Xen_wrap_2_args(gxg_glTexCoord2f_w, gxg_glTexCoord2f) 4217 Xen_wrap_2_args(gxg_glTexCoord2i_w, gxg_glTexCoord2i) 4218 Xen_wrap_2_args(gxg_glTexCoord2s_w, gxg_glTexCoord2s) 4219 Xen_wrap_3_args(gxg_glTexCoord3d_w, gxg_glTexCoord3d) 4220 Xen_wrap_3_args(gxg_glTexCoord3f_w, gxg_glTexCoord3f) 4221 Xen_wrap_3_args(gxg_glTexCoord3i_w, gxg_glTexCoord3i) 4222 Xen_wrap_3_args(gxg_glTexCoord3s_w, gxg_glTexCoord3s) 4223 Xen_wrap_4_args(gxg_glTexCoord4d_w, gxg_glTexCoord4d) 4224 Xen_wrap_4_args(gxg_glTexCoord4f_w, gxg_glTexCoord4f) 4225 Xen_wrap_4_args(gxg_glTexCoord4i_w, gxg_glTexCoord4i) 4226 Xen_wrap_4_args(gxg_glTexCoord4s_w, gxg_glTexCoord4s) 4227 Xen_wrap_2_args(gxg_glRasterPos2d_w, gxg_glRasterPos2d) 4228 Xen_wrap_2_args(gxg_glRasterPos2f_w, gxg_glRasterPos2f) 4229 Xen_wrap_2_args(gxg_glRasterPos2i_w, gxg_glRasterPos2i) 4230 Xen_wrap_2_args(gxg_glRasterPos2s_w, gxg_glRasterPos2s) 4231 Xen_wrap_3_args(gxg_glRasterPos3d_w, gxg_glRasterPos3d) 4232 Xen_wrap_3_args(gxg_glRasterPos3f_w, gxg_glRasterPos3f) 4233 Xen_wrap_3_args(gxg_glRasterPos3i_w, gxg_glRasterPos3i) 4234 Xen_wrap_3_args(gxg_glRasterPos3s_w, gxg_glRasterPos3s) 4235 Xen_wrap_4_args(gxg_glRasterPos4d_w, gxg_glRasterPos4d) 4236 Xen_wrap_4_args(gxg_glRasterPos4f_w, gxg_glRasterPos4f) 4237 Xen_wrap_4_args(gxg_glRasterPos4i_w, gxg_glRasterPos4i) 4238 Xen_wrap_4_args(gxg_glRasterPos4s_w, gxg_glRasterPos4s) 4239 Xen_wrap_4_args(gxg_glRectd_w, gxg_glRectd) 4240 Xen_wrap_4_args(gxg_glRectf_w, gxg_glRectf) 4241 Xen_wrap_4_args(gxg_glRecti_w, gxg_glRecti) 4242 Xen_wrap_4_args(gxg_glRects_w, gxg_glRects) 4243 Xen_wrap_4_args(gxg_glVertexPointer_w, gxg_glVertexPointer) 4244 Xen_wrap_3_args(gxg_glNormalPointer_w, gxg_glNormalPointer) 4245 Xen_wrap_4_args(gxg_glColorPointer_w, gxg_glColorPointer) 4246 Xen_wrap_3_args(gxg_glIndexPointer_w, gxg_glIndexPointer) 4247 Xen_wrap_4_args(gxg_glTexCoordPointer_w, gxg_glTexCoordPointer) 4248 Xen_wrap_2_args(gxg_glEdgeFlagPointer_w, gxg_glEdgeFlagPointer) 4249 Xen_wrap_2_optional_args(gxg_glGetPointerv_w, gxg_glGetPointerv) 4250 Xen_wrap_1_arg(gxg_glArrayElement_w, gxg_glArrayElement) 4251 Xen_wrap_3_args(gxg_glDrawArrays_w, gxg_glDrawArrays) 4252 Xen_wrap_4_args(gxg_glDrawElements_w, gxg_glDrawElements) 4253 Xen_wrap_3_args(gxg_glInterleavedArrays_w, gxg_glInterleavedArrays) 4254 Xen_wrap_1_arg(gxg_glShadeModel_w, gxg_glShadeModel) 4255 Xen_wrap_3_args(gxg_glLightf_w, gxg_glLightf) 4256 Xen_wrap_3_args(gxg_glLighti_w, gxg_glLighti) 4257 Xen_wrap_3_optional_args(gxg_glGetLightfv_w, gxg_glGetLightfv) 4258 Xen_wrap_3_optional_args(gxg_glGetLightiv_w, gxg_glGetLightiv) 4259 Xen_wrap_2_args(gxg_glLightModelf_w, gxg_glLightModelf) 4260 Xen_wrap_2_args(gxg_glLightModeli_w, gxg_glLightModeli) 4261 Xen_wrap_3_args(gxg_glMaterialf_w, gxg_glMaterialf) 4262 Xen_wrap_3_args(gxg_glMateriali_w, gxg_glMateriali) 4263 Xen_wrap_3_optional_args(gxg_glGetMaterialfv_w, gxg_glGetMaterialfv) 4264 Xen_wrap_3_optional_args(gxg_glGetMaterialiv_w, gxg_glGetMaterialiv) 4265 Xen_wrap_2_args(gxg_glColorMaterial_w, gxg_glColorMaterial) 4266 Xen_wrap_2_args(gxg_glPixelZoom_w, gxg_glPixelZoom) 4267 Xen_wrap_2_args(gxg_glPixelStoref_w, gxg_glPixelStoref) 4268 Xen_wrap_2_args(gxg_glPixelStorei_w, gxg_glPixelStorei) 4269 Xen_wrap_2_args(gxg_glPixelTransferf_w, gxg_glPixelTransferf) 4270 Xen_wrap_2_args(gxg_glPixelTransferi_w, gxg_glPixelTransferi) 4271 Xen_wrap_2_optional_args(gxg_glGetPixelMapfv_w, gxg_glGetPixelMapfv) 4272 Xen_wrap_2_optional_args(gxg_glGetPixelMapuiv_w, gxg_glGetPixelMapuiv) 4273 Xen_wrap_2_optional_args(gxg_glGetPixelMapusv_w, gxg_glGetPixelMapusv) 4274 Xen_wrap_7_args(gxg_glBitmap_w, gxg_glBitmap) 4275 Xen_wrap_7_args(gxg_glReadPixels_w, gxg_glReadPixels) 4276 Xen_wrap_5_args(gxg_glDrawPixels_w, gxg_glDrawPixels) 4277 Xen_wrap_5_args(gxg_glCopyPixels_w, gxg_glCopyPixels) 4278 Xen_wrap_3_args(gxg_glStencilFunc_w, gxg_glStencilFunc) 4279 Xen_wrap_1_arg(gxg_glStencilMask_w, gxg_glStencilMask) 4280 Xen_wrap_3_args(gxg_glStencilOp_w, gxg_glStencilOp) 4281 Xen_wrap_1_arg(gxg_glClearStencil_w, gxg_glClearStencil) 4282 Xen_wrap_3_args(gxg_glTexGend_w, gxg_glTexGend) 4283 Xen_wrap_3_args(gxg_glTexGenf_w, gxg_glTexGenf) 4284 Xen_wrap_3_args(gxg_glTexGeni_w, gxg_glTexGeni) 4285 Xen_wrap_3_optional_args(gxg_glGetTexGendv_w, gxg_glGetTexGendv) 4286 Xen_wrap_3_optional_args(gxg_glGetTexGenfv_w, gxg_glGetTexGenfv) 4287 Xen_wrap_3_optional_args(gxg_glGetTexGeniv_w, gxg_glGetTexGeniv) 4288 Xen_wrap_3_args(gxg_glTexEnvf_w, gxg_glTexEnvf) 4289 Xen_wrap_3_args(gxg_glTexEnvi_w, gxg_glTexEnvi) 4290 Xen_wrap_3_optional_args(gxg_glGetTexEnvfv_w, gxg_glGetTexEnvfv) 4291 Xen_wrap_3_optional_args(gxg_glGetTexEnviv_w, gxg_glGetTexEnviv) 4292 Xen_wrap_3_args(gxg_glTexParameterf_w, gxg_glTexParameterf) 4293 Xen_wrap_3_args(gxg_glTexParameteri_w, gxg_glTexParameteri) 4294 Xen_wrap_3_optional_args(gxg_glGetTexParameterfv_w, gxg_glGetTexParameterfv) 4295 Xen_wrap_3_optional_args(gxg_glGetTexParameteriv_w, gxg_glGetTexParameteriv) 4296 Xen_wrap_4_optional_args(gxg_glGetTexLevelParameterfv_w, gxg_glGetTexLevelParameterfv) 4297 Xen_wrap_4_optional_args(gxg_glGetTexLevelParameteriv_w, gxg_glGetTexLevelParameteriv) 4298 Xen_wrap_any_args(gxg_glTexImage1D_w, gxg_glTexImage1D) 4299 Xen_wrap_any_args(gxg_glTexImage2D_w, gxg_glTexImage2D) 4300 Xen_wrap_2_args(gxg_glGenTextures_w, gxg_glGenTextures) 4301 Xen_wrap_2_args(gxg_glDeleteTextures_w, gxg_glDeleteTextures) 4302 Xen_wrap_2_args(gxg_glBindTexture_w, gxg_glBindTexture) 4303 Xen_wrap_3_args(gxg_glAreTexturesResident_w, gxg_glAreTexturesResident) 4304 Xen_wrap_1_arg(gxg_glIsTexture_w, gxg_glIsTexture) 4305 Xen_wrap_7_args(gxg_glTexSubImage1D_w, gxg_glTexSubImage1D) 4306 Xen_wrap_any_args(gxg_glTexSubImage2D_w, gxg_glTexSubImage2D) 4307 Xen_wrap_7_args(gxg_glCopyTexImage1D_w, gxg_glCopyTexImage1D) 4308 Xen_wrap_any_args(gxg_glCopyTexImage2D_w, gxg_glCopyTexImage2D) 4309 Xen_wrap_6_args(gxg_glCopyTexSubImage1D_w, gxg_glCopyTexSubImage1D) 4310 Xen_wrap_any_args(gxg_glCopyTexSubImage2D_w, gxg_glCopyTexSubImage2D) 4311 Xen_wrap_6_args(gxg_glMap1d_w, gxg_glMap1d) 4312 Xen_wrap_6_args(gxg_glMap1f_w, gxg_glMap1f) 4313 Xen_wrap_any_args(gxg_glMap2d_w, gxg_glMap2d) 4314 Xen_wrap_any_args(gxg_glMap2f_w, gxg_glMap2f) 4315 Xen_wrap_3_optional_args(gxg_glGetMapdv_w, gxg_glGetMapdv) 4316 Xen_wrap_3_optional_args(gxg_glGetMapfv_w, gxg_glGetMapfv) 4317 Xen_wrap_3_optional_args(gxg_glGetMapiv_w, gxg_glGetMapiv) 4318 Xen_wrap_1_arg(gxg_glEvalCoord1d_w, gxg_glEvalCoord1d) 4319 Xen_wrap_1_arg(gxg_glEvalCoord1f_w, gxg_glEvalCoord1f) 4320 Xen_wrap_2_args(gxg_glEvalCoord2d_w, gxg_glEvalCoord2d) 4321 Xen_wrap_2_args(gxg_glEvalCoord2f_w, gxg_glEvalCoord2f) 4322 Xen_wrap_3_args(gxg_glMapGrid1d_w, gxg_glMapGrid1d) 4323 Xen_wrap_3_args(gxg_glMapGrid1f_w, gxg_glMapGrid1f) 4324 Xen_wrap_6_args(gxg_glMapGrid2d_w, gxg_glMapGrid2d) 4325 Xen_wrap_6_args(gxg_glMapGrid2f_w, gxg_glMapGrid2f) 4326 Xen_wrap_1_arg(gxg_glEvalPoint1_w, gxg_glEvalPoint1) 4327 Xen_wrap_2_args(gxg_glEvalPoint2_w, gxg_glEvalPoint2) 4328 Xen_wrap_3_args(gxg_glEvalMesh1_w, gxg_glEvalMesh1) 4329 Xen_wrap_5_args(gxg_glEvalMesh2_w, gxg_glEvalMesh2) 4330 Xen_wrap_2_args(gxg_glFogf_w, gxg_glFogf) 4331 Xen_wrap_2_args(gxg_glFogi_w, gxg_glFogi) 4332 Xen_wrap_3_args(gxg_glFeedbackBuffer_w, gxg_glFeedbackBuffer) 4333 Xen_wrap_1_arg(gxg_glPassThrough_w, gxg_glPassThrough) 4334 Xen_wrap_2_args(gxg_glSelectBuffer_w, gxg_glSelectBuffer) 4335 Xen_wrap_no_args(gxg_glInitNames_w, gxg_glInitNames) 4336 Xen_wrap_1_arg(gxg_glLoadName_w, gxg_glLoadName) 4337 Xen_wrap_1_arg(gxg_glPushName_w, gxg_glPushName) 4338 Xen_wrap_no_args(gxg_glPopName_w, gxg_glPopName) 4339 Xen_wrap_6_args(gxg_glDrawRangeElements_w, gxg_glDrawRangeElements) 4340 Xen_wrap_any_args(gxg_glTexImage3D_w, gxg_glTexImage3D) 4341 Xen_wrap_any_args(gxg_glTexSubImage3D_w, gxg_glTexSubImage3D) 4342 Xen_wrap_any_args(gxg_glCopyTexSubImage3D_w, gxg_glCopyTexSubImage3D) 4343 Xen_wrap_6_args(gxg_glColorTable_w, gxg_glColorTable) 4344 Xen_wrap_6_args(gxg_glColorSubTable_w, gxg_glColorSubTable) 4345 Xen_wrap_5_args(gxg_glCopyColorSubTable_w, gxg_glCopyColorSubTable) 4346 Xen_wrap_5_args(gxg_glCopyColorTable_w, gxg_glCopyColorTable) 4347 Xen_wrap_3_optional_args(gxg_glGetColorTableParameterfv_w, gxg_glGetColorTableParameterfv) 4348 Xen_wrap_3_optional_args(gxg_glGetColorTableParameteriv_w, gxg_glGetColorTableParameteriv) 4349 Xen_wrap_1_arg(gxg_glBlendEquation_w, gxg_glBlendEquation) 4350 Xen_wrap_4_args(gxg_glBlendColor_w, gxg_glBlendColor) 4351 Xen_wrap_4_args(gxg_glHistogram_w, gxg_glHistogram) 4352 Xen_wrap_1_arg(gxg_glResetHistogram_w, gxg_glResetHistogram) 4353 Xen_wrap_5_args(gxg_glGetHistogram_w, gxg_glGetHistogram) 4354 Xen_wrap_3_optional_args(gxg_glGetHistogramParameterfv_w, gxg_glGetHistogramParameterfv) 4355 Xen_wrap_3_optional_args(gxg_glGetHistogramParameteriv_w, gxg_glGetHistogramParameteriv) 4356 Xen_wrap_3_args(gxg_glMinmax_w, gxg_glMinmax) 4357 Xen_wrap_1_arg(gxg_glResetMinmax_w, gxg_glResetMinmax) 4358 Xen_wrap_5_args(gxg_glGetMinmax_w, gxg_glGetMinmax) 4359 Xen_wrap_3_optional_args(gxg_glGetMinmaxParameterfv_w, gxg_glGetMinmaxParameterfv) 4360 Xen_wrap_3_optional_args(gxg_glGetMinmaxParameteriv_w, gxg_glGetMinmaxParameteriv) 4361 Xen_wrap_6_args(gxg_glConvolutionFilter1D_w, gxg_glConvolutionFilter1D) 4362 Xen_wrap_7_args(gxg_glConvolutionFilter2D_w, gxg_glConvolutionFilter2D) 4363 Xen_wrap_3_args(gxg_glConvolutionParameterf_w, gxg_glConvolutionParameterf) 4364 Xen_wrap_3_args(gxg_glConvolutionParameteri_w, gxg_glConvolutionParameteri) 4365 Xen_wrap_5_args(gxg_glCopyConvolutionFilter1D_w, gxg_glCopyConvolutionFilter1D) 4366 Xen_wrap_6_args(gxg_glCopyConvolutionFilter2D_w, gxg_glCopyConvolutionFilter2D) 4367 Xen_wrap_any_args(gxg_glSeparableFilter2D_w, gxg_glSeparableFilter2D) 4368 #if HAVE_GLU 4369 Xen_wrap_1_arg(gxg_gluBeginCurve_w, gxg_gluBeginCurve) 4370 #ifdef GLU_VERSION_1_2 4371 Xen_wrap_1_arg(gxg_gluBeginPolygon_w, gxg_gluBeginPolygon) 4372 #endif 4373 Xen_wrap_1_arg(gxg_gluBeginSurface_w, gxg_gluBeginSurface) 4374 Xen_wrap_1_arg(gxg_gluBeginTrim_w, gxg_gluBeginTrim) 4375 Xen_wrap_any_args(gxg_gluBuild1DMipmapLevels_w, gxg_gluBuild1DMipmapLevels) 4376 Xen_wrap_6_args(gxg_gluBuild1DMipmaps_w, gxg_gluBuild1DMipmaps) 4377 Xen_wrap_any_args(gxg_gluBuild2DMipmapLevels_w, gxg_gluBuild2DMipmapLevels) 4378 Xen_wrap_7_args(gxg_gluBuild2DMipmaps_w, gxg_gluBuild2DMipmaps) 4379 Xen_wrap_any_args(gxg_gluBuild3DMipmapLevels_w, gxg_gluBuild3DMipmapLevels) 4380 Xen_wrap_any_args(gxg_gluBuild3DMipmaps_w, gxg_gluBuild3DMipmaps) 4381 Xen_wrap_2_args(gxg_gluCheckExtension_w, gxg_gluCheckExtension) 4382 Xen_wrap_6_args(gxg_gluCylinder_w, gxg_gluCylinder) 4383 Xen_wrap_1_arg(gxg_gluDeleteNurbsRenderer_w, gxg_gluDeleteNurbsRenderer) 4384 Xen_wrap_1_arg(gxg_gluDeleteQuadric_w, gxg_gluDeleteQuadric) 4385 #ifdef GLU_VERSION_1_2 4386 Xen_wrap_1_arg(gxg_gluDeleteTess_w, gxg_gluDeleteTess) 4387 #endif 4388 Xen_wrap_5_args(gxg_gluDisk_w, gxg_gluDisk) 4389 Xen_wrap_1_arg(gxg_gluEndCurve_w, gxg_gluEndCurve) 4390 #ifdef GLU_VERSION_1_2 4391 Xen_wrap_1_arg(gxg_gluEndPolygon_w, gxg_gluEndPolygon) 4392 #endif 4393 Xen_wrap_1_arg(gxg_gluEndSurface_w, gxg_gluEndSurface) 4394 Xen_wrap_1_arg(gxg_gluEndTrim_w, gxg_gluEndTrim) 4395 Xen_wrap_1_arg(gxg_gluErrorString_w, gxg_gluErrorString) 4396 Xen_wrap_3_args(gxg_gluGetNurbsProperty_w, gxg_gluGetNurbsProperty) 4397 Xen_wrap_1_arg(gxg_gluGetString_w, gxg_gluGetString) 4398 #ifdef GLU_VERSION_1_2 4399 Xen_wrap_3_args(gxg_gluGetTessProperty_w, gxg_gluGetTessProperty) 4400 #endif 4401 Xen_wrap_4_args(gxg_gluLoadSamplingMatrices_w, gxg_gluLoadSamplingMatrices) 4402 Xen_wrap_any_args(gxg_gluLookAt_w, gxg_gluLookAt) 4403 Xen_wrap_no_args(gxg_gluNewNurbsRenderer_w, gxg_gluNewNurbsRenderer) 4404 Xen_wrap_no_args(gxg_gluNewQuadric_w, gxg_gluNewQuadric) 4405 #ifdef GLU_VERSION_1_2 4406 Xen_wrap_no_args(gxg_gluNewTess_w, gxg_gluNewTess) 4407 #endif 4408 #ifdef GLU_VERSION_1_2 4409 Xen_wrap_2_args(gxg_gluNextContour_w, gxg_gluNextContour) 4410 #endif 4411 Xen_wrap_3_args(gxg_gluNurbsCallback_w, gxg_gluNurbsCallback) 4412 Xen_wrap_2_args(gxg_gluNurbsCallbackData_w, gxg_gluNurbsCallbackData) 4413 Xen_wrap_7_args(gxg_gluNurbsCurve_w, gxg_gluNurbsCurve) 4414 Xen_wrap_3_args(gxg_gluNurbsProperty_w, gxg_gluNurbsProperty) 4415 Xen_wrap_any_args(gxg_gluNurbsSurface_w, gxg_gluNurbsSurface) 4416 Xen_wrap_4_args(gxg_gluOrtho2D_w, gxg_gluOrtho2D) 4417 Xen_wrap_7_args(gxg_gluPartialDisk_w, gxg_gluPartialDisk) 4418 Xen_wrap_4_args(gxg_gluPerspective_w, gxg_gluPerspective) 4419 Xen_wrap_5_args(gxg_gluPickMatrix_w, gxg_gluPickMatrix) 4420 Xen_wrap_any_args(gxg_gluProject_w, gxg_gluProject) 4421 Xen_wrap_5_args(gxg_gluPwlCurve_w, gxg_gluPwlCurve) 4422 Xen_wrap_3_args(gxg_gluQuadricCallback_w, gxg_gluQuadricCallback) 4423 Xen_wrap_2_args(gxg_gluQuadricDrawStyle_w, gxg_gluQuadricDrawStyle) 4424 Xen_wrap_2_args(gxg_gluQuadricNormals_w, gxg_gluQuadricNormals) 4425 Xen_wrap_2_args(gxg_gluQuadricOrientation_w, gxg_gluQuadricOrientation) 4426 Xen_wrap_2_args(gxg_gluQuadricTexture_w, gxg_gluQuadricTexture) 4427 Xen_wrap_any_args(gxg_gluScaleImage_w, gxg_gluScaleImage) 4428 Xen_wrap_4_args(gxg_gluSphere_w, gxg_gluSphere) 4429 #ifdef GLU_VERSION_1_2 4430 Xen_wrap_1_arg(gxg_gluTessBeginContour_w, gxg_gluTessBeginContour) 4431 #endif 4432 #ifdef GLU_VERSION_1_2 4433 Xen_wrap_2_args(gxg_gluTessBeginPolygon_w, gxg_gluTessBeginPolygon) 4434 #endif 4435 Xen_wrap_3_args(gxg_gluTessCallback_w, gxg_gluTessCallback) 4436 #ifdef GLU_VERSION_1_2 4437 Xen_wrap_1_arg(gxg_gluTessEndContour_w, gxg_gluTessEndContour) 4438 #endif 4439 #ifdef GLU_VERSION_1_2 4440 Xen_wrap_1_arg(gxg_gluTessEndPolygon_w, gxg_gluTessEndPolygon) 4441 #endif 4442 #ifdef GLU_VERSION_1_2 4443 Xen_wrap_4_args(gxg_gluTessNormal_w, gxg_gluTessNormal) 4444 #endif 4445 #ifdef GLU_VERSION_1_2 4446 Xen_wrap_3_args(gxg_gluTessProperty_w, gxg_gluTessProperty) 4447 #endif 4448 #ifdef GLU_VERSION_1_2 4449 Xen_wrap_3_args(gxg_gluTessVertex_w, gxg_gluTessVertex) 4450 #endif 4451 Xen_wrap_any_args(gxg_gluUnProject_w, gxg_gluUnProject) 4452 Xen_wrap_any_args(gxg_gluUnProject4_w, gxg_gluUnProject4) 4453 #endif 4454 static void define_functions(void) 4455 { 4456 #if HAVE_SCHEME 4457 static s7_pointer s_boolean, s_integer, s_real, s_any; 4458 static s7_pointer pl_pit, pl_piit, pl_piiit, pl_tr, pl_trrrrt, pl_tb, pl_bi, pl_bt, pl_bit, pl_prrrrtttrrt, pl_i, pl_t, pl_prrrt, pl_ti, pl_tir, pl_tit, pl_ttr, pl_ttb, pl_tti, pl_tiit, pl_ttri, pl_ttit, pl_ttir, pl_tiir, pl_tiib, pl_tiiit, pl_tiiib, pl_ttiti, pl_ttrri, pl_tiiiit, pl_tirrir, pl_ttrrri, pl_tibiit, pl_tirriit, pl_ttrriir, pl_ttititi, pl_iiiiiit, pl_tiiiiit, pl_tiirrrrt, pl_tiiiiiiit, pl_tiiiiiiiit, pl_tirriirriit, pl_tiiiiiiiiit, pl_tiiiiiiiiiit, pl_iiiiitiiit, pl_ttititiiti, pl_iiiiiiiit, pl_iiiiiiiiiiit, pl_iiiiiiit, pl_iiiiiiiiiit, pl_iiiiiiiiit, pl_tiiiiiit; 4459 #if USE_MOTIF 4460 static s7_pointer pl_pt, pl_pttit, pl_tttti, pl_ttttb; 4461 #endif 4462 4463 s_boolean = s7_make_symbol(s7, "boolean?"); 4464 s_integer = s7_make_symbol(s7, "integer?"); 4465 s_real = s7_make_symbol(s7, "real?"); 4466 s_any = s7_t(s7); 4467 4468 pl_pit = s7_make_circular_signature(s7, 2, 3, s_any, s_integer, s_any); 4469 pl_piit = s7_make_circular_signature(s7, 3, 4, s_any, s_integer, s_integer, s_any); 4470 pl_piiit = s7_make_circular_signature(s7, 4, 5, s_any, s_integer, s_integer, s_integer, s_any); 4471 pl_tr = s7_make_circular_signature(s7, 1, 2, s_any, s_real); 4472 pl_trrrrt = s7_make_circular_signature(s7, 5, 6, s_any, s_real, s_real, s_real, s_real, s_any); 4473 pl_tb = s7_make_circular_signature(s7, 1, 2, s_any, s_boolean); 4474 pl_bi = s7_make_circular_signature(s7, 1, 2, s_boolean, s_integer); 4475 pl_bt = s7_make_circular_signature(s7, 1, 2, s_boolean, s_any); 4476 pl_bit = s7_make_circular_signature(s7, 2, 3, s_boolean, s_integer, s_any); 4477 pl_prrrrtttrrt = s7_make_circular_signature(s7, 10, 11, s_any, s_real, s_real, s_real, s_real, s_any, s_any, s_any, s_real, s_real, s_any); 4478 pl_i = s7_make_circular_signature(s7, 0, 1, s_integer); 4479 pl_t = s7_make_circular_signature(s7, 0, 1, s_any); 4480 pl_prrrt = s7_make_circular_signature(s7, 4, 5, s_any, s_real, s_real, s_real, s_any); 4481 pl_ti = s7_make_circular_signature(s7, 1, 2, s_any, s_integer); 4482 pl_tir = s7_make_circular_signature(s7, 2, 3, s_any, s_integer, s_real); 4483 pl_tit = s7_make_circular_signature(s7, 2, 3, s_any, s_integer, s_any); 4484 pl_ttr = s7_make_circular_signature(s7, 2, 3, s_any, s_any, s_real); 4485 pl_ttb = s7_make_circular_signature(s7, 2, 3, s_any, s_any, s_boolean); 4486 pl_tti = s7_make_circular_signature(s7, 2, 3, s_any, s_any, s_integer); 4487 pl_tiit = s7_make_circular_signature(s7, 3, 4, s_any, s_integer, s_integer, s_any); 4488 pl_ttri = s7_make_circular_signature(s7, 3, 4, s_any, s_any, s_real, s_integer); 4489 pl_ttit = s7_make_circular_signature(s7, 3, 4, s_any, s_any, s_integer, s_any); 4490 pl_ttir = s7_make_circular_signature(s7, 3, 4, s_any, s_any, s_integer, s_real); 4491 pl_tiir = s7_make_circular_signature(s7, 3, 4, s_any, s_integer, s_integer, s_real); 4492 pl_tiib = s7_make_circular_signature(s7, 3, 4, s_any, s_integer, s_integer, s_boolean); 4493 pl_tiiit = s7_make_circular_signature(s7, 4, 5, s_any, s_integer, s_integer, s_integer, s_any); 4494 pl_tiiib = s7_make_circular_signature(s7, 4, 5, s_any, s_integer, s_integer, s_integer, s_boolean); 4495 pl_ttiti = s7_make_circular_signature(s7, 4, 5, s_any, s_any, s_integer, s_any, s_integer); 4496 pl_ttrri = s7_make_circular_signature(s7, 4, 5, s_any, s_any, s_real, s_real, s_integer); 4497 pl_tiiiit = s7_make_circular_signature(s7, 5, 6, s_any, s_integer, s_integer, s_integer, s_integer, s_any); 4498 pl_tirrir = s7_make_circular_signature(s7, 5, 6, s_any, s_integer, s_real, s_real, s_integer, s_real); 4499 pl_ttrrri = s7_make_circular_signature(s7, 5, 6, s_any, s_any, s_real, s_real, s_real, s_integer); 4500 pl_tibiit = s7_make_circular_signature(s7, 5, 6, s_any, s_integer, s_boolean, s_integer, s_integer, s_any); 4501 pl_tirriit = s7_make_circular_signature(s7, 6, 7, s_any, s_integer, s_real, s_real, s_integer, s_integer, s_any); 4502 pl_ttrriir = s7_make_circular_signature(s7, 6, 7, s_any, s_any, s_real, s_real, s_integer, s_integer, s_real); 4503 pl_ttititi = s7_make_circular_signature(s7, 6, 7, s_any, s_any, s_integer, s_any, s_integer, s_any, s_integer); 4504 pl_iiiiiit = s7_make_circular_signature(s7, 6, 7, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4505 pl_tiiiiit = s7_make_circular_signature(s7, 6, 7, s_any, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4506 pl_tiirrrrt = s7_make_circular_signature(s7, 7, 8, s_any, s_integer, s_integer, s_real, s_real, s_real, s_real, s_any); 4507 pl_tiiiiiiit = s7_make_circular_signature(s7, 8, 9, s_any, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4508 pl_tiiiiiiiit = s7_make_circular_signature(s7, 9, 10, s_any, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4509 pl_tirriirriit = s7_make_circular_signature(s7, 10, 11, s_any, s_integer, s_real, s_real, s_integer, s_integer, s_real, s_real, s_integer, s_integer, s_any); 4510 pl_tiiiiiiiiit = s7_make_circular_signature(s7, 10, 11, s_any, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4511 pl_tiiiiiiiiiit = s7_make_circular_signature(s7, 11, 12, s_any, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4512 pl_iiiiitiiit = s7_make_circular_signature(s7, 9, 10, s_integer, s_integer, s_integer, s_integer, s_integer, s_any, s_integer, s_integer, s_integer, s_any); 4513 pl_ttititiiti = s7_make_circular_signature(s7, 9, 10, s_any, s_any, s_integer, s_any, s_integer, s_any, s_integer, s_integer, s_any, s_integer); 4514 pl_iiiiiiiit = s7_make_circular_signature(s7, 8, 9, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4515 pl_iiiiiiiiiiit = s7_make_circular_signature(s7, 11, 12, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4516 pl_iiiiiiit = s7_make_circular_signature(s7, 7, 8, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4517 pl_iiiiiiiiiit = s7_make_circular_signature(s7, 10, 11, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4518 pl_iiiiiiiiit = s7_make_circular_signature(s7, 9, 10, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4519 pl_tiiiiiit = s7_make_circular_signature(s7, 7, 8, s_any, s_integer, s_integer, s_integer, s_integer, s_integer, s_integer, s_any); 4520 4521 #if USE_MOTIF 4522 pl_pt = s7_make_circular_signature(s7, 1, 2, s_any, s_any); 4523 pl_pttit = s7_make_circular_signature(s7, 4, 5, s_any, s_any, s_any, s_integer, s_any); 4524 pl_tttti = s7_make_circular_signature(s7, 4, 5, s_any, s_any, s_any, s_any, s_integer); 4525 pl_ttttb = s7_make_circular_signature(s7, 4, 5, s_any, s_any, s_any, s_any, s_boolean); 4526 #endif 4527 #endif 4528 4529 #if HAVE_SCHEME 4530 #define gl_define_procedure(Name, Value, A1, A2, A3, Help, Sig) s7_define_typed_function(s7, XL_PRE #Name XL_POST, Value, A1, A2, A3, Help, Sig) 4531 #else 4532 #define gl_define_procedure(Name, Value, A1, A2, A3, Help, Sig) Xen_define_safe_procedure(XL_PRE #Name XL_POST, Value, A1, A2, A3, Help) 4533 #endif 4534 4535 #if USE_MOTIF 4536 gl_define_procedure(glXChooseVisual, gxg_glXChooseVisual_w, 3, 0, 0, H_glXChooseVisual, pl_ttit); 4537 gl_define_procedure(glXCopyContext, gxg_glXCopyContext_w, 4, 0, 0, H_glXCopyContext, pl_tttti); 4538 gl_define_procedure(glXCreateContext, gxg_glXCreateContext_w, 4, 0, 0, H_glXCreateContext, pl_ttttb); 4539 gl_define_procedure(glXCreateGLXPixmap, gxg_glXCreateGLXPixmap_w, 3, 0, 0, H_glXCreateGLXPixmap, pl_t); 4540 gl_define_procedure(glXDestroyContext, gxg_glXDestroyContext_w, 2, 0, 0, H_glXDestroyContext, pl_t); 4541 gl_define_procedure(glXDestroyGLXPixmap, gxg_glXDestroyGLXPixmap_w, 2, 0, 0, H_glXDestroyGLXPixmap, pl_t); 4542 gl_define_procedure(glXGetConfig, gxg_glXGetConfig_w, 3, 1, 0, H_glXGetConfig, pl_pttit); 4543 gl_define_procedure(glXGetCurrentContext, gxg_glXGetCurrentContext_w, 0, 0, 0, H_glXGetCurrentContext, pl_t); 4544 gl_define_procedure(glXGetCurrentDrawable, gxg_glXGetCurrentDrawable_w, 0, 0, 0, H_glXGetCurrentDrawable, pl_t); 4545 gl_define_procedure(glXIsDirect, gxg_glXIsDirect_w, 2, 0, 0, H_glXIsDirect, pl_bt); 4546 gl_define_procedure(glXMakeCurrent, gxg_glXMakeCurrent_w, 3, 0, 0, H_glXMakeCurrent, pl_bt); 4547 gl_define_procedure(glXQueryExtension, gxg_glXQueryExtension_w, 1, 2, 0, H_glXQueryExtension, pl_pt); 4548 gl_define_procedure(glXQueryVersion, gxg_glXQueryVersion_w, 1, 2, 0, H_glXQueryVersion, pl_pt); 4549 gl_define_procedure(glXSwapBuffers, gxg_glXSwapBuffers_w, 2, 0, 0, H_glXSwapBuffers, pl_t); 4550 gl_define_procedure(glXUseXFont, gxg_glXUseXFont_w, 4, 0, 0, H_glXUseXFont, pl_tti); 4551 gl_define_procedure(glXWaitGL, gxg_glXWaitGL_w, 0, 0, 0, H_glXWaitGL, pl_t); 4552 gl_define_procedure(glXWaitX, gxg_glXWaitX_w, 0, 0, 0, H_glXWaitX, pl_t); 4553 gl_define_procedure(glXGetClientString, gxg_glXGetClientString_w, 2, 0, 0, H_glXGetClientString, pl_tti); 4554 gl_define_procedure(glXQueryServerString, gxg_glXQueryServerString_w, 3, 0, 0, H_glXQueryServerString, pl_tti); 4555 gl_define_procedure(glXQueryExtensionsString, gxg_glXQueryExtensionsString_w, 2, 0, 0, H_glXQueryExtensionsString, pl_tti); 4556 #endif 4557 gl_define_procedure(glClearIndex, gxg_glClearIndex_w, 1, 0, 0, H_glClearIndex, pl_tr); 4558 gl_define_procedure(glClearColor, gxg_glClearColor_w, 4, 0, 0, H_glClearColor, pl_tr); 4559 gl_define_procedure(glClear, gxg_glClear_w, 1, 0, 0, H_glClear, pl_ti); 4560 gl_define_procedure(glIndexMask, gxg_glIndexMask_w, 1, 0, 0, H_glIndexMask, pl_ti); 4561 gl_define_procedure(glColorMask, gxg_glColorMask_w, 4, 0, 0, H_glColorMask, pl_tb); 4562 gl_define_procedure(glAlphaFunc, gxg_glAlphaFunc_w, 2, 0, 0, H_glAlphaFunc, pl_tir); 4563 gl_define_procedure(glBlendFunc, gxg_glBlendFunc_w, 2, 0, 0, H_glBlendFunc, pl_ti); 4564 gl_define_procedure(glLogicOp, gxg_glLogicOp_w, 1, 0, 0, H_glLogicOp, pl_ti); 4565 gl_define_procedure(glCullFace, gxg_glCullFace_w, 1, 0, 0, H_glCullFace, pl_ti); 4566 gl_define_procedure(glFrontFace, gxg_glFrontFace_w, 1, 0, 0, H_glFrontFace, pl_ti); 4567 gl_define_procedure(glPointSize, gxg_glPointSize_w, 1, 0, 0, H_glPointSize, pl_tr); 4568 gl_define_procedure(glLineWidth, gxg_glLineWidth_w, 1, 0, 0, H_glLineWidth, pl_tr); 4569 gl_define_procedure(glLineStipple, gxg_glLineStipple_w, 2, 0, 0, H_glLineStipple, pl_ti); 4570 gl_define_procedure(glPolygonMode, gxg_glPolygonMode_w, 2, 0, 0, H_glPolygonMode, pl_ti); 4571 gl_define_procedure(glPolygonOffset, gxg_glPolygonOffset_w, 2, 0, 0, H_glPolygonOffset, pl_tr); 4572 gl_define_procedure(glPolygonStipple, gxg_glPolygonStipple_w, 1, 0, 0, H_glPolygonStipple, pl_t); 4573 gl_define_procedure(glEdgeFlag, gxg_glEdgeFlag_w, 1, 0, 0, H_glEdgeFlag, pl_tb); 4574 gl_define_procedure(glScissor, gxg_glScissor_w, 4, 0, 0, H_glScissor, pl_ti); 4575 gl_define_procedure(glClipPlane, gxg_glClipPlane_w, 2, 0, 0, H_glClipPlane, pl_tit); 4576 gl_define_procedure(glGetClipPlane, gxg_glGetClipPlane_w, 1, 1, 0, H_glGetClipPlane, pl_pit); 4577 gl_define_procedure(glDrawBuffer, gxg_glDrawBuffer_w, 1, 0, 0, H_glDrawBuffer, pl_ti); 4578 gl_define_procedure(glReadBuffer, gxg_glReadBuffer_w, 1, 0, 0, H_glReadBuffer, pl_ti); 4579 gl_define_procedure(glEnable, gxg_glEnable_w, 1, 0, 0, H_glEnable, pl_ti); 4580 gl_define_procedure(glDisable, gxg_glDisable_w, 1, 0, 0, H_glDisable, pl_ti); 4581 gl_define_procedure(glIsEnabled, gxg_glIsEnabled_w, 1, 0, 0, H_glIsEnabled, pl_bi); 4582 gl_define_procedure(glEnableClientState, gxg_glEnableClientState_w, 1, 0, 0, H_glEnableClientState, pl_ti); 4583 gl_define_procedure(glDisableClientState, gxg_glDisableClientState_w, 1, 0, 0, H_glDisableClientState, pl_ti); 4584 gl_define_procedure(glGetBooleanv, gxg_glGetBooleanv_w, 1, 1, 0, H_glGetBooleanv, pl_pit); 4585 gl_define_procedure(glGetDoublev, gxg_glGetDoublev_w, 1, 1, 0, H_glGetDoublev, pl_pit); 4586 gl_define_procedure(glGetFloatv, gxg_glGetFloatv_w, 1, 1, 0, H_glGetFloatv, pl_pit); 4587 gl_define_procedure(glGetIntegerv, gxg_glGetIntegerv_w, 1, 1, 0, H_glGetIntegerv, pl_pit); 4588 gl_define_procedure(glPushAttrib, gxg_glPushAttrib_w, 1, 0, 0, H_glPushAttrib, pl_ti); 4589 gl_define_procedure(glPopAttrib, gxg_glPopAttrib_w, 0, 0, 0, H_glPopAttrib, pl_t); 4590 gl_define_procedure(glPushClientAttrib, gxg_glPushClientAttrib_w, 1, 0, 0, H_glPushClientAttrib, pl_ti); 4591 gl_define_procedure(glPopClientAttrib, gxg_glPopClientAttrib_w, 0, 0, 0, H_glPopClientAttrib, pl_t); 4592 gl_define_procedure(glRenderMode, gxg_glRenderMode_w, 1, 0, 0, H_glRenderMode, pl_i); 4593 gl_define_procedure(glGetError, gxg_glGetError_w, 0, 0, 0, H_glGetError, pl_i); 4594 gl_define_procedure(glGetString, gxg_glGetString_w, 1, 0, 0, H_glGetString, pl_ti); 4595 gl_define_procedure(glFinish, gxg_glFinish_w, 0, 0, 0, H_glFinish, pl_t); 4596 gl_define_procedure(glFlush, gxg_glFlush_w, 0, 0, 0, H_glFlush, pl_t); 4597 gl_define_procedure(glHint, gxg_glHint_w, 2, 0, 0, H_glHint, pl_ti); 4598 gl_define_procedure(glClearDepth, gxg_glClearDepth_w, 1, 0, 0, H_glClearDepth, pl_tr); 4599 gl_define_procedure(glDepthFunc, gxg_glDepthFunc_w, 1, 0, 0, H_glDepthFunc, pl_ti); 4600 gl_define_procedure(glDepthMask, gxg_glDepthMask_w, 1, 0, 0, H_glDepthMask, pl_tb); 4601 gl_define_procedure(glDepthRange, gxg_glDepthRange_w, 2, 0, 0, H_glDepthRange, pl_tr); 4602 gl_define_procedure(glClearAccum, gxg_glClearAccum_w, 4, 0, 0, H_glClearAccum, pl_tr); 4603 gl_define_procedure(glAccum, gxg_glAccum_w, 2, 0, 0, H_glAccum, pl_tir); 4604 gl_define_procedure(glMatrixMode, gxg_glMatrixMode_w, 1, 0, 0, H_glMatrixMode, pl_ti); 4605 gl_define_procedure(glOrtho, gxg_glOrtho_w, 6, 0, 0, H_glOrtho, pl_tr); 4606 gl_define_procedure(glFrustum, gxg_glFrustum_w, 6, 0, 0, H_glFrustum, pl_tr); 4607 gl_define_procedure(glViewport, gxg_glViewport_w, 4, 0, 0, H_glViewport, pl_ti); 4608 gl_define_procedure(glPushMatrix, gxg_glPushMatrix_w, 0, 0, 0, H_glPushMatrix, pl_t); 4609 gl_define_procedure(glPopMatrix, gxg_glPopMatrix_w, 0, 0, 0, H_glPopMatrix, pl_t); 4610 gl_define_procedure(glLoadIdentity, gxg_glLoadIdentity_w, 0, 0, 0, H_glLoadIdentity, pl_t); 4611 gl_define_procedure(glLoadMatrixd, gxg_glLoadMatrixd_w, 1, 0, 0, H_glLoadMatrixd, pl_t); 4612 gl_define_procedure(glLoadMatrixf, gxg_glLoadMatrixf_w, 1, 0, 0, H_glLoadMatrixf, pl_t); 4613 gl_define_procedure(glMultMatrixd, gxg_glMultMatrixd_w, 1, 0, 0, H_glMultMatrixd, pl_t); 4614 gl_define_procedure(glMultMatrixf, gxg_glMultMatrixf_w, 1, 0, 0, H_glMultMatrixf, pl_t); 4615 gl_define_procedure(glRotated, gxg_glRotated_w, 4, 0, 0, H_glRotated, pl_tr); 4616 gl_define_procedure(glRotatef, gxg_glRotatef_w, 4, 0, 0, H_glRotatef, pl_tr); 4617 gl_define_procedure(glScaled, gxg_glScaled_w, 3, 0, 0, H_glScaled, pl_tr); 4618 gl_define_procedure(glScalef, gxg_glScalef_w, 3, 0, 0, H_glScalef, pl_tr); 4619 gl_define_procedure(glTranslated, gxg_glTranslated_w, 3, 0, 0, H_glTranslated, pl_tr); 4620 gl_define_procedure(glTranslatef, gxg_glTranslatef_w, 3, 0, 0, H_glTranslatef, pl_tr); 4621 gl_define_procedure(glIsList, gxg_glIsList_w, 1, 0, 0, H_glIsList, pl_bi); 4622 gl_define_procedure(glDeleteLists, gxg_glDeleteLists_w, 2, 0, 0, H_glDeleteLists, pl_ti); 4623 gl_define_procedure(glGenLists, gxg_glGenLists_w, 1, 0, 0, H_glGenLists, pl_i); 4624 gl_define_procedure(glNewList, gxg_glNewList_w, 2, 0, 0, H_glNewList, pl_ti); 4625 gl_define_procedure(glEndList, gxg_glEndList_w, 0, 0, 0, H_glEndList, pl_t); 4626 gl_define_procedure(glCallList, gxg_glCallList_w, 1, 0, 0, H_glCallList, pl_ti); 4627 gl_define_procedure(glCallLists, gxg_glCallLists_w, 3, 0, 0, H_glCallLists, pl_tiit); 4628 gl_define_procedure(glListBase, gxg_glListBase_w, 1, 0, 0, H_glListBase, pl_ti); 4629 gl_define_procedure(glBegin, gxg_glBegin_w, 1, 0, 0, H_glBegin, pl_ti); 4630 gl_define_procedure(glEnd, gxg_glEnd_w, 0, 0, 0, H_glEnd, pl_t); 4631 gl_define_procedure(glVertex2d, gxg_glVertex2d_w, 2, 0, 0, H_glVertex2d, pl_tr); 4632 gl_define_procedure(glVertex2f, gxg_glVertex2f_w, 2, 0, 0, H_glVertex2f, pl_tr); 4633 gl_define_procedure(glVertex2i, gxg_glVertex2i_w, 2, 0, 0, H_glVertex2i, pl_ti); 4634 gl_define_procedure(glVertex2s, gxg_glVertex2s_w, 2, 0, 0, H_glVertex2s, pl_ti); 4635 gl_define_procedure(glVertex3d, gxg_glVertex3d_w, 3, 0, 0, H_glVertex3d, pl_tr); 4636 gl_define_procedure(glVertex3f, gxg_glVertex3f_w, 3, 0, 0, H_glVertex3f, pl_tr); 4637 gl_define_procedure(glVertex3i, gxg_glVertex3i_w, 3, 0, 0, H_glVertex3i, pl_ti); 4638 gl_define_procedure(glVertex3s, gxg_glVertex3s_w, 3, 0, 0, H_glVertex3s, pl_ti); 4639 gl_define_procedure(glVertex4d, gxg_glVertex4d_w, 4, 0, 0, H_glVertex4d, pl_tr); 4640 gl_define_procedure(glVertex4f, gxg_glVertex4f_w, 4, 0, 0, H_glVertex4f, pl_tr); 4641 gl_define_procedure(glVertex4i, gxg_glVertex4i_w, 4, 0, 0, H_glVertex4i, pl_ti); 4642 gl_define_procedure(glVertex4s, gxg_glVertex4s_w, 4, 0, 0, H_glVertex4s, pl_ti); 4643 gl_define_procedure(glNormal3b, gxg_glNormal3b_w, 3, 0, 0, H_glNormal3b, pl_ti); 4644 gl_define_procedure(glNormal3d, gxg_glNormal3d_w, 3, 0, 0, H_glNormal3d, pl_tr); 4645 gl_define_procedure(glNormal3f, gxg_glNormal3f_w, 3, 0, 0, H_glNormal3f, pl_tr); 4646 gl_define_procedure(glNormal3i, gxg_glNormal3i_w, 3, 0, 0, H_glNormal3i, pl_ti); 4647 gl_define_procedure(glNormal3s, gxg_glNormal3s_w, 3, 0, 0, H_glNormal3s, pl_ti); 4648 gl_define_procedure(glIndexd, gxg_glIndexd_w, 1, 0, 0, H_glIndexd, pl_tr); 4649 gl_define_procedure(glIndexf, gxg_glIndexf_w, 1, 0, 0, H_glIndexf, pl_tr); 4650 gl_define_procedure(glIndexi, gxg_glIndexi_w, 1, 0, 0, H_glIndexi, pl_ti); 4651 gl_define_procedure(glIndexs, gxg_glIndexs_w, 1, 0, 0, H_glIndexs, pl_ti); 4652 gl_define_procedure(glIndexub, gxg_glIndexub_w, 1, 0, 0, H_glIndexub, pl_ti); 4653 gl_define_procedure(glColor3b, gxg_glColor3b_w, 3, 0, 0, H_glColor3b, pl_ti); 4654 gl_define_procedure(glColor3d, gxg_glColor3d_w, 3, 0, 0, H_glColor3d, pl_tr); 4655 gl_define_procedure(glColor3f, gxg_glColor3f_w, 3, 0, 0, H_glColor3f, pl_tr); 4656 gl_define_procedure(glColor3i, gxg_glColor3i_w, 3, 0, 0, H_glColor3i, pl_ti); 4657 gl_define_procedure(glColor3s, gxg_glColor3s_w, 3, 0, 0, H_glColor3s, pl_ti); 4658 gl_define_procedure(glColor3ub, gxg_glColor3ub_w, 3, 0, 0, H_glColor3ub, pl_ti); 4659 gl_define_procedure(glColor3ui, gxg_glColor3ui_w, 3, 0, 0, H_glColor3ui, pl_ti); 4660 gl_define_procedure(glColor3us, gxg_glColor3us_w, 3, 0, 0, H_glColor3us, pl_ti); 4661 gl_define_procedure(glColor4b, gxg_glColor4b_w, 4, 0, 0, H_glColor4b, pl_ti); 4662 gl_define_procedure(glColor4d, gxg_glColor4d_w, 4, 0, 0, H_glColor4d, pl_tr); 4663 gl_define_procedure(glColor4f, gxg_glColor4f_w, 4, 0, 0, H_glColor4f, pl_tr); 4664 gl_define_procedure(glColor4i, gxg_glColor4i_w, 4, 0, 0, H_glColor4i, pl_ti); 4665 gl_define_procedure(glColor4s, gxg_glColor4s_w, 4, 0, 0, H_glColor4s, pl_ti); 4666 gl_define_procedure(glColor4ub, gxg_glColor4ub_w, 4, 0, 0, H_glColor4ub, pl_ti); 4667 gl_define_procedure(glColor4ui, gxg_glColor4ui_w, 4, 0, 0, H_glColor4ui, pl_ti); 4668 gl_define_procedure(glColor4us, gxg_glColor4us_w, 4, 0, 0, H_glColor4us, pl_ti); 4669 gl_define_procedure(glTexCoord1d, gxg_glTexCoord1d_w, 1, 0, 0, H_glTexCoord1d, pl_tr); 4670 gl_define_procedure(glTexCoord1f, gxg_glTexCoord1f_w, 1, 0, 0, H_glTexCoord1f, pl_tr); 4671 gl_define_procedure(glTexCoord1i, gxg_glTexCoord1i_w, 1, 0, 0, H_glTexCoord1i, pl_ti); 4672 gl_define_procedure(glTexCoord1s, gxg_glTexCoord1s_w, 1, 0, 0, H_glTexCoord1s, pl_ti); 4673 gl_define_procedure(glTexCoord2d, gxg_glTexCoord2d_w, 2, 0, 0, H_glTexCoord2d, pl_tr); 4674 gl_define_procedure(glTexCoord2f, gxg_glTexCoord2f_w, 2, 0, 0, H_glTexCoord2f, pl_tr); 4675 gl_define_procedure(glTexCoord2i, gxg_glTexCoord2i_w, 2, 0, 0, H_glTexCoord2i, pl_ti); 4676 gl_define_procedure(glTexCoord2s, gxg_glTexCoord2s_w, 2, 0, 0, H_glTexCoord2s, pl_ti); 4677 gl_define_procedure(glTexCoord3d, gxg_glTexCoord3d_w, 3, 0, 0, H_glTexCoord3d, pl_tr); 4678 gl_define_procedure(glTexCoord3f, gxg_glTexCoord3f_w, 3, 0, 0, H_glTexCoord3f, pl_tr); 4679 gl_define_procedure(glTexCoord3i, gxg_glTexCoord3i_w, 3, 0, 0, H_glTexCoord3i, pl_ti); 4680 gl_define_procedure(glTexCoord3s, gxg_glTexCoord3s_w, 3, 0, 0, H_glTexCoord3s, pl_ti); 4681 gl_define_procedure(glTexCoord4d, gxg_glTexCoord4d_w, 4, 0, 0, H_glTexCoord4d, pl_tr); 4682 gl_define_procedure(glTexCoord4f, gxg_glTexCoord4f_w, 4, 0, 0, H_glTexCoord4f, pl_tr); 4683 gl_define_procedure(glTexCoord4i, gxg_glTexCoord4i_w, 4, 0, 0, H_glTexCoord4i, pl_ti); 4684 gl_define_procedure(glTexCoord4s, gxg_glTexCoord4s_w, 4, 0, 0, H_glTexCoord4s, pl_ti); 4685 gl_define_procedure(glRasterPos2d, gxg_glRasterPos2d_w, 2, 0, 0, H_glRasterPos2d, pl_tr); 4686 gl_define_procedure(glRasterPos2f, gxg_glRasterPos2f_w, 2, 0, 0, H_glRasterPos2f, pl_tr); 4687 gl_define_procedure(glRasterPos2i, gxg_glRasterPos2i_w, 2, 0, 0, H_glRasterPos2i, pl_ti); 4688 gl_define_procedure(glRasterPos2s, gxg_glRasterPos2s_w, 2, 0, 0, H_glRasterPos2s, pl_ti); 4689 gl_define_procedure(glRasterPos3d, gxg_glRasterPos3d_w, 3, 0, 0, H_glRasterPos3d, pl_tr); 4690 gl_define_procedure(glRasterPos3f, gxg_glRasterPos3f_w, 3, 0, 0, H_glRasterPos3f, pl_tr); 4691 gl_define_procedure(glRasterPos3i, gxg_glRasterPos3i_w, 3, 0, 0, H_glRasterPos3i, pl_ti); 4692 gl_define_procedure(glRasterPos3s, gxg_glRasterPos3s_w, 3, 0, 0, H_glRasterPos3s, pl_ti); 4693 gl_define_procedure(glRasterPos4d, gxg_glRasterPos4d_w, 4, 0, 0, H_glRasterPos4d, pl_tr); 4694 gl_define_procedure(glRasterPos4f, gxg_glRasterPos4f_w, 4, 0, 0, H_glRasterPos4f, pl_tr); 4695 gl_define_procedure(glRasterPos4i, gxg_glRasterPos4i_w, 4, 0, 0, H_glRasterPos4i, pl_ti); 4696 gl_define_procedure(glRasterPos4s, gxg_glRasterPos4s_w, 4, 0, 0, H_glRasterPos4s, pl_ti); 4697 gl_define_procedure(glRectd, gxg_glRectd_w, 4, 0, 0, H_glRectd, pl_tr); 4698 gl_define_procedure(glRectf, gxg_glRectf_w, 4, 0, 0, H_glRectf, pl_tr); 4699 gl_define_procedure(glRecti, gxg_glRecti_w, 4, 0, 0, H_glRecti, pl_ti); 4700 gl_define_procedure(glRects, gxg_glRects_w, 4, 0, 0, H_glRects, pl_ti); 4701 gl_define_procedure(glVertexPointer, gxg_glVertexPointer_w, 4, 0, 0, H_glVertexPointer, pl_tiiit); 4702 gl_define_procedure(glNormalPointer, gxg_glNormalPointer_w, 3, 0, 0, H_glNormalPointer, pl_tiit); 4703 gl_define_procedure(glColorPointer, gxg_glColorPointer_w, 4, 0, 0, H_glColorPointer, pl_tiiit); 4704 gl_define_procedure(glIndexPointer, gxg_glIndexPointer_w, 3, 0, 0, H_glIndexPointer, pl_tiit); 4705 gl_define_procedure(glTexCoordPointer, gxg_glTexCoordPointer_w, 4, 0, 0, H_glTexCoordPointer, pl_tiiit); 4706 gl_define_procedure(glEdgeFlagPointer, gxg_glEdgeFlagPointer_w, 2, 0, 0, H_glEdgeFlagPointer, pl_tit); 4707 gl_define_procedure(glGetPointerv, gxg_glGetPointerv_w, 1, 1, 0, H_glGetPointerv, pl_pit); 4708 gl_define_procedure(glArrayElement, gxg_glArrayElement_w, 1, 0, 0, H_glArrayElement, pl_ti); 4709 gl_define_procedure(glDrawArrays, gxg_glDrawArrays_w, 3, 0, 0, H_glDrawArrays, pl_ti); 4710 gl_define_procedure(glDrawElements, gxg_glDrawElements_w, 4, 0, 0, H_glDrawElements, pl_tiiit); 4711 gl_define_procedure(glInterleavedArrays, gxg_glInterleavedArrays_w, 3, 0, 0, H_glInterleavedArrays, pl_tiit); 4712 gl_define_procedure(glShadeModel, gxg_glShadeModel_w, 1, 0, 0, H_glShadeModel, pl_ti); 4713 gl_define_procedure(glLightf, gxg_glLightf_w, 3, 0, 0, H_glLightf, pl_tiir); 4714 gl_define_procedure(glLighti, gxg_glLighti_w, 3, 0, 0, H_glLighti, pl_ti); 4715 gl_define_procedure(glGetLightfv, gxg_glGetLightfv_w, 2, 1, 0, H_glGetLightfv, pl_piit); 4716 gl_define_procedure(glGetLightiv, gxg_glGetLightiv_w, 2, 1, 0, H_glGetLightiv, pl_piit); 4717 gl_define_procedure(glLightModelf, gxg_glLightModelf_w, 2, 0, 0, H_glLightModelf, pl_tir); 4718 gl_define_procedure(glLightModeli, gxg_glLightModeli_w, 2, 0, 0, H_glLightModeli, pl_ti); 4719 gl_define_procedure(glMaterialf, gxg_glMaterialf_w, 3, 0, 0, H_glMaterialf, pl_tiir); 4720 gl_define_procedure(glMateriali, gxg_glMateriali_w, 3, 0, 0, H_glMateriali, pl_ti); 4721 gl_define_procedure(glGetMaterialfv, gxg_glGetMaterialfv_w, 2, 1, 0, H_glGetMaterialfv, pl_piit); 4722 gl_define_procedure(glGetMaterialiv, gxg_glGetMaterialiv_w, 2, 1, 0, H_glGetMaterialiv, pl_piit); 4723 gl_define_procedure(glColorMaterial, gxg_glColorMaterial_w, 2, 0, 0, H_glColorMaterial, pl_ti); 4724 gl_define_procedure(glPixelZoom, gxg_glPixelZoom_w, 2, 0, 0, H_glPixelZoom, pl_tr); 4725 gl_define_procedure(glPixelStoref, gxg_glPixelStoref_w, 2, 0, 0, H_glPixelStoref, pl_tir); 4726 gl_define_procedure(glPixelStorei, gxg_glPixelStorei_w, 2, 0, 0, H_glPixelStorei, pl_ti); 4727 gl_define_procedure(glPixelTransferf, gxg_glPixelTransferf_w, 2, 0, 0, H_glPixelTransferf, pl_tir); 4728 gl_define_procedure(glPixelTransferi, gxg_glPixelTransferi_w, 2, 0, 0, H_glPixelTransferi, pl_ti); 4729 gl_define_procedure(glGetPixelMapfv, gxg_glGetPixelMapfv_w, 1, 1, 0, H_glGetPixelMapfv, pl_pit); 4730 gl_define_procedure(glGetPixelMapuiv, gxg_glGetPixelMapuiv_w, 1, 1, 0, H_glGetPixelMapuiv, pl_pit); 4731 gl_define_procedure(glGetPixelMapusv, gxg_glGetPixelMapusv_w, 1, 1, 0, H_glGetPixelMapusv, pl_pit); 4732 gl_define_procedure(glBitmap, gxg_glBitmap_w, 7, 0, 0, H_glBitmap, pl_tiirrrrt); 4733 gl_define_procedure(glReadPixels, gxg_glReadPixels_w, 7, 0, 0, H_glReadPixels, pl_tiiiiiit); 4734 gl_define_procedure(glDrawPixels, gxg_glDrawPixels_w, 5, 0, 0, H_glDrawPixels, pl_tiiiit); 4735 gl_define_procedure(glCopyPixels, gxg_glCopyPixels_w, 5, 0, 0, H_glCopyPixels, pl_ti); 4736 gl_define_procedure(glStencilFunc, gxg_glStencilFunc_w, 3, 0, 0, H_glStencilFunc, pl_ti); 4737 gl_define_procedure(glStencilMask, gxg_glStencilMask_w, 1, 0, 0, H_glStencilMask, pl_ti); 4738 gl_define_procedure(glStencilOp, gxg_glStencilOp_w, 3, 0, 0, H_glStencilOp, pl_ti); 4739 gl_define_procedure(glClearStencil, gxg_glClearStencil_w, 1, 0, 0, H_glClearStencil, pl_ti); 4740 gl_define_procedure(glTexGend, gxg_glTexGend_w, 3, 0, 0, H_glTexGend, pl_tiir); 4741 gl_define_procedure(glTexGenf, gxg_glTexGenf_w, 3, 0, 0, H_glTexGenf, pl_tiir); 4742 gl_define_procedure(glTexGeni, gxg_glTexGeni_w, 3, 0, 0, H_glTexGeni, pl_ti); 4743 gl_define_procedure(glGetTexGendv, gxg_glGetTexGendv_w, 2, 1, 0, H_glGetTexGendv, pl_piit); 4744 gl_define_procedure(glGetTexGenfv, gxg_glGetTexGenfv_w, 2, 1, 0, H_glGetTexGenfv, pl_piit); 4745 gl_define_procedure(glGetTexGeniv, gxg_glGetTexGeniv_w, 2, 1, 0, H_glGetTexGeniv, pl_piit); 4746 gl_define_procedure(glTexEnvf, gxg_glTexEnvf_w, 3, 0, 0, H_glTexEnvf, pl_tiir); 4747 gl_define_procedure(glTexEnvi, gxg_glTexEnvi_w, 3, 0, 0, H_glTexEnvi, pl_ti); 4748 gl_define_procedure(glGetTexEnvfv, gxg_glGetTexEnvfv_w, 2, 1, 0, H_glGetTexEnvfv, pl_piit); 4749 gl_define_procedure(glGetTexEnviv, gxg_glGetTexEnviv_w, 2, 1, 0, H_glGetTexEnviv, pl_piit); 4750 gl_define_procedure(glTexParameterf, gxg_glTexParameterf_w, 3, 0, 0, H_glTexParameterf, pl_tiir); 4751 gl_define_procedure(glTexParameteri, gxg_glTexParameteri_w, 3, 0, 0, H_glTexParameteri, pl_ti); 4752 gl_define_procedure(glGetTexParameterfv, gxg_glGetTexParameterfv_w, 2, 1, 0, H_glGetTexParameterfv, pl_piit); 4753 gl_define_procedure(glGetTexParameteriv, gxg_glGetTexParameteriv_w, 2, 1, 0, H_glGetTexParameteriv, pl_piit); 4754 gl_define_procedure(glGetTexLevelParameterfv, gxg_glGetTexLevelParameterfv_w, 3, 1, 0, H_glGetTexLevelParameterfv, pl_piiit); 4755 gl_define_procedure(glGetTexLevelParameteriv, gxg_glGetTexLevelParameteriv_w, 3, 1, 0, H_glGetTexLevelParameteriv, pl_piiit); 4756 gl_define_procedure(glTexImage1D, gxg_glTexImage1D_w, 0, 0, 1, H_glTexImage1D, pl_tiiiiiiit); 4757 gl_define_procedure(glTexImage2D, gxg_glTexImage2D_w, 0, 0, 1, H_glTexImage2D, pl_tiiiiiiiit); 4758 gl_define_procedure(glGenTextures, gxg_glGenTextures_w, 2, 0, 0, H_glGenTextures, pl_tit); 4759 gl_define_procedure(glDeleteTextures, gxg_glDeleteTextures_w, 2, 0, 0, H_glDeleteTextures, pl_tit); 4760 gl_define_procedure(glBindTexture, gxg_glBindTexture_w, 2, 0, 0, H_glBindTexture, pl_ti); 4761 gl_define_procedure(glAreTexturesResident, gxg_glAreTexturesResident_w, 3, 0, 0, H_glAreTexturesResident, pl_bit); 4762 gl_define_procedure(glIsTexture, gxg_glIsTexture_w, 1, 0, 0, H_glIsTexture, pl_bi); 4763 gl_define_procedure(glTexSubImage1D, gxg_glTexSubImage1D_w, 7, 0, 0, H_glTexSubImage1D, pl_tiiiiiit); 4764 gl_define_procedure(glTexSubImage2D, gxg_glTexSubImage2D_w, 0, 0, 1, H_glTexSubImage2D, pl_tiiiiiiiit); 4765 gl_define_procedure(glCopyTexImage1D, gxg_glCopyTexImage1D_w, 7, 0, 0, H_glCopyTexImage1D, pl_ti); 4766 gl_define_procedure(glCopyTexImage2D, gxg_glCopyTexImage2D_w, 0, 0, 1, H_glCopyTexImage2D, pl_ti); 4767 gl_define_procedure(glCopyTexSubImage1D, gxg_glCopyTexSubImage1D_w, 6, 0, 0, H_glCopyTexSubImage1D, pl_ti); 4768 gl_define_procedure(glCopyTexSubImage2D, gxg_glCopyTexSubImage2D_w, 0, 0, 1, H_glCopyTexSubImage2D, pl_ti); 4769 gl_define_procedure(glMap1d, gxg_glMap1d_w, 6, 0, 0, H_glMap1d, pl_tirriit); 4770 gl_define_procedure(glMap1f, gxg_glMap1f_w, 6, 0, 0, H_glMap1f, pl_tirriit); 4771 gl_define_procedure(glMap2d, gxg_glMap2d_w, 0, 0, 1, H_glMap2d, pl_tirriirriit); 4772 gl_define_procedure(glMap2f, gxg_glMap2f_w, 0, 0, 1, H_glMap2f, pl_tirriirriit); 4773 gl_define_procedure(glGetMapdv, gxg_glGetMapdv_w, 2, 1, 0, H_glGetMapdv, pl_piit); 4774 gl_define_procedure(glGetMapfv, gxg_glGetMapfv_w, 2, 1, 0, H_glGetMapfv, pl_piit); 4775 gl_define_procedure(glGetMapiv, gxg_glGetMapiv_w, 2, 1, 0, H_glGetMapiv, pl_piit); 4776 gl_define_procedure(glEvalCoord1d, gxg_glEvalCoord1d_w, 1, 0, 0, H_glEvalCoord1d, pl_tr); 4777 gl_define_procedure(glEvalCoord1f, gxg_glEvalCoord1f_w, 1, 0, 0, H_glEvalCoord1f, pl_tr); 4778 gl_define_procedure(glEvalCoord2d, gxg_glEvalCoord2d_w, 2, 0, 0, H_glEvalCoord2d, pl_tr); 4779 gl_define_procedure(glEvalCoord2f, gxg_glEvalCoord2f_w, 2, 0, 0, H_glEvalCoord2f, pl_tr); 4780 gl_define_procedure(glMapGrid1d, gxg_glMapGrid1d_w, 3, 0, 0, H_glMapGrid1d, pl_tir); 4781 gl_define_procedure(glMapGrid1f, gxg_glMapGrid1f_w, 3, 0, 0, H_glMapGrid1f, pl_tir); 4782 gl_define_procedure(glMapGrid2d, gxg_glMapGrid2d_w, 6, 0, 0, H_glMapGrid2d, pl_tirrir); 4783 gl_define_procedure(glMapGrid2f, gxg_glMapGrid2f_w, 6, 0, 0, H_glMapGrid2f, pl_tirrir); 4784 gl_define_procedure(glEvalPoint1, gxg_glEvalPoint1_w, 1, 0, 0, H_glEvalPoint1, pl_ti); 4785 gl_define_procedure(glEvalPoint2, gxg_glEvalPoint2_w, 2, 0, 0, H_glEvalPoint2, pl_ti); 4786 gl_define_procedure(glEvalMesh1, gxg_glEvalMesh1_w, 3, 0, 0, H_glEvalMesh1, pl_ti); 4787 gl_define_procedure(glEvalMesh2, gxg_glEvalMesh2_w, 5, 0, 0, H_glEvalMesh2, pl_ti); 4788 gl_define_procedure(glFogf, gxg_glFogf_w, 2, 0, 0, H_glFogf, pl_tir); 4789 gl_define_procedure(glFogi, gxg_glFogi_w, 2, 0, 0, H_glFogi, pl_ti); 4790 gl_define_procedure(glFeedbackBuffer, gxg_glFeedbackBuffer_w, 3, 0, 0, H_glFeedbackBuffer, pl_tiit); 4791 gl_define_procedure(glPassThrough, gxg_glPassThrough_w, 1, 0, 0, H_glPassThrough, pl_tr); 4792 gl_define_procedure(glSelectBuffer, gxg_glSelectBuffer_w, 2, 0, 0, H_glSelectBuffer, pl_tit); 4793 gl_define_procedure(glInitNames, gxg_glInitNames_w, 0, 0, 0, H_glInitNames, pl_t); 4794 gl_define_procedure(glLoadName, gxg_glLoadName_w, 1, 0, 0, H_glLoadName, pl_ti); 4795 gl_define_procedure(glPushName, gxg_glPushName_w, 1, 0, 0, H_glPushName, pl_ti); 4796 gl_define_procedure(glPopName, gxg_glPopName_w, 0, 0, 0, H_glPopName, pl_t); 4797 gl_define_procedure(glDrawRangeElements, gxg_glDrawRangeElements_w, 6, 0, 0, H_glDrawRangeElements, pl_tiiiiit); 4798 gl_define_procedure(glTexImage3D, gxg_glTexImage3D_w, 0, 0, 1, H_glTexImage3D, pl_tiiiiiiiiit); 4799 gl_define_procedure(glTexSubImage3D, gxg_glTexSubImage3D_w, 0, 0, 1, H_glTexSubImage3D, pl_tiiiiiiiiiit); 4800 gl_define_procedure(glCopyTexSubImage3D, gxg_glCopyTexSubImage3D_w, 0, 0, 1, H_glCopyTexSubImage3D, pl_ti); 4801 gl_define_procedure(glColorTable, gxg_glColorTable_w, 6, 0, 0, H_glColorTable, pl_tiiiiit); 4802 gl_define_procedure(glColorSubTable, gxg_glColorSubTable_w, 6, 0, 0, H_glColorSubTable, pl_tiiiiit); 4803 gl_define_procedure(glCopyColorSubTable, gxg_glCopyColorSubTable_w, 5, 0, 0, H_glCopyColorSubTable, pl_ti); 4804 gl_define_procedure(glCopyColorTable, gxg_glCopyColorTable_w, 5, 0, 0, H_glCopyColorTable, pl_ti); 4805 gl_define_procedure(glGetColorTableParameterfv, gxg_glGetColorTableParameterfv_w, 2, 1, 0, H_glGetColorTableParameterfv, pl_piit); 4806 gl_define_procedure(glGetColorTableParameteriv, gxg_glGetColorTableParameteriv_w, 2, 1, 0, H_glGetColorTableParameteriv, pl_piit); 4807 gl_define_procedure(glBlendEquation, gxg_glBlendEquation_w, 1, 0, 0, H_glBlendEquation, pl_ti); 4808 gl_define_procedure(glBlendColor, gxg_glBlendColor_w, 4, 0, 0, H_glBlendColor, pl_tr); 4809 gl_define_procedure(glHistogram, gxg_glHistogram_w, 4, 0, 0, H_glHistogram, pl_tiiib); 4810 gl_define_procedure(glResetHistogram, gxg_glResetHistogram_w, 1, 0, 0, H_glResetHistogram, pl_ti); 4811 gl_define_procedure(glGetHistogram, gxg_glGetHistogram_w, 5, 0, 0, H_glGetHistogram, pl_tibiit); 4812 gl_define_procedure(glGetHistogramParameterfv, gxg_glGetHistogramParameterfv_w, 2, 1, 0, H_glGetHistogramParameterfv, pl_piit); 4813 gl_define_procedure(glGetHistogramParameteriv, gxg_glGetHistogramParameteriv_w, 2, 1, 0, H_glGetHistogramParameteriv, pl_piit); 4814 gl_define_procedure(glMinmax, gxg_glMinmax_w, 3, 0, 0, H_glMinmax, pl_tiib); 4815 gl_define_procedure(glResetMinmax, gxg_glResetMinmax_w, 1, 0, 0, H_glResetMinmax, pl_ti); 4816 gl_define_procedure(glGetMinmax, gxg_glGetMinmax_w, 5, 0, 0, H_glGetMinmax, pl_tibiit); 4817 gl_define_procedure(glGetMinmaxParameterfv, gxg_glGetMinmaxParameterfv_w, 2, 1, 0, H_glGetMinmaxParameterfv, pl_piit); 4818 gl_define_procedure(glGetMinmaxParameteriv, gxg_glGetMinmaxParameteriv_w, 2, 1, 0, H_glGetMinmaxParameteriv, pl_piit); 4819 gl_define_procedure(glConvolutionFilter1D, gxg_glConvolutionFilter1D_w, 6, 0, 0, H_glConvolutionFilter1D, pl_tiiiiit); 4820 gl_define_procedure(glConvolutionFilter2D, gxg_glConvolutionFilter2D_w, 7, 0, 0, H_glConvolutionFilter2D, pl_tiiiiiit); 4821 gl_define_procedure(glConvolutionParameterf, gxg_glConvolutionParameterf_w, 3, 0, 0, H_glConvolutionParameterf, pl_tiir); 4822 gl_define_procedure(glConvolutionParameteri, gxg_glConvolutionParameteri_w, 3, 0, 0, H_glConvolutionParameteri, pl_ti); 4823 gl_define_procedure(glCopyConvolutionFilter1D, gxg_glCopyConvolutionFilter1D_w, 5, 0, 0, H_glCopyConvolutionFilter1D, pl_ti); 4824 gl_define_procedure(glCopyConvolutionFilter2D, gxg_glCopyConvolutionFilter2D_w, 6, 0, 0, H_glCopyConvolutionFilter2D, pl_ti); 4825 gl_define_procedure(glSeparableFilter2D, gxg_glSeparableFilter2D_w, 0, 0, 1, H_glSeparableFilter2D, pl_tiiiiiit); 4826 #if HAVE_GLU 4827 gl_define_procedure(gluBeginCurve, gxg_gluBeginCurve_w, 1, 0, 0, H_gluBeginCurve, pl_t); 4828 #ifdef GLU_VERSION_1_2 4829 gl_define_procedure(gluBeginPolygon, gxg_gluBeginPolygon_w, 1, 0, 0, H_gluBeginPolygon, pl_t); 4830 #endif 4831 gl_define_procedure(gluBeginSurface, gxg_gluBeginSurface_w, 1, 0, 0, H_gluBeginSurface, pl_t); 4832 gl_define_procedure(gluBeginTrim, gxg_gluBeginTrim_w, 1, 0, 0, H_gluBeginTrim, pl_t); 4833 gl_define_procedure(gluBuild1DMipmapLevels, gxg_gluBuild1DMipmapLevels_w, 0, 0, 1, H_gluBuild1DMipmapLevels, pl_iiiiiiiiit); 4834 gl_define_procedure(gluBuild1DMipmaps, gxg_gluBuild1DMipmaps_w, 6, 0, 0, H_gluBuild1DMipmaps, pl_iiiiiit); 4835 gl_define_procedure(gluBuild2DMipmapLevels, gxg_gluBuild2DMipmapLevels_w, 0, 0, 1, H_gluBuild2DMipmapLevels, pl_iiiiiiiiiit); 4836 gl_define_procedure(gluBuild2DMipmaps, gxg_gluBuild2DMipmaps_w, 7, 0, 0, H_gluBuild2DMipmaps, pl_iiiiiiit); 4837 gl_define_procedure(gluBuild3DMipmapLevels, gxg_gluBuild3DMipmapLevels_w, 0, 0, 1, H_gluBuild3DMipmapLevels, pl_iiiiiiiiiiit); 4838 gl_define_procedure(gluBuild3DMipmaps, gxg_gluBuild3DMipmaps_w, 0, 0, 1, H_gluBuild3DMipmaps, pl_iiiiiiiit); 4839 gl_define_procedure(gluCheckExtension, gxg_gluCheckExtension_w, 2, 0, 0, H_gluCheckExtension, pl_bt); 4840 gl_define_procedure(gluCylinder, gxg_gluCylinder_w, 6, 0, 0, H_gluCylinder, pl_ttrrri); 4841 gl_define_procedure(gluDeleteNurbsRenderer, gxg_gluDeleteNurbsRenderer_w, 1, 0, 0, H_gluDeleteNurbsRenderer, pl_t); 4842 gl_define_procedure(gluDeleteQuadric, gxg_gluDeleteQuadric_w, 1, 0, 0, H_gluDeleteQuadric, pl_t); 4843 #ifdef GLU_VERSION_1_2 4844 gl_define_procedure(gluDeleteTess, gxg_gluDeleteTess_w, 1, 0, 0, H_gluDeleteTess, pl_t); 4845 #endif 4846 gl_define_procedure(gluDisk, gxg_gluDisk_w, 5, 0, 0, H_gluDisk, pl_ttrri); 4847 gl_define_procedure(gluEndCurve, gxg_gluEndCurve_w, 1, 0, 0, H_gluEndCurve, pl_t); 4848 #ifdef GLU_VERSION_1_2 4849 gl_define_procedure(gluEndPolygon, gxg_gluEndPolygon_w, 1, 0, 0, H_gluEndPolygon, pl_t); 4850 #endif 4851 gl_define_procedure(gluEndSurface, gxg_gluEndSurface_w, 1, 0, 0, H_gluEndSurface, pl_t); 4852 gl_define_procedure(gluEndTrim, gxg_gluEndTrim_w, 1, 0, 0, H_gluEndTrim, pl_t); 4853 gl_define_procedure(gluErrorString, gxg_gluErrorString_w, 1, 0, 0, H_gluErrorString, pl_ti); 4854 gl_define_procedure(gluGetNurbsProperty, gxg_gluGetNurbsProperty_w, 3, 0, 0, H_gluGetNurbsProperty, pl_ttit); 4855 gl_define_procedure(gluGetString, gxg_gluGetString_w, 1, 0, 0, H_gluGetString, pl_ti); 4856 #ifdef GLU_VERSION_1_2 4857 gl_define_procedure(gluGetTessProperty, gxg_gluGetTessProperty_w, 3, 0, 0, H_gluGetTessProperty, pl_ttit); 4858 #endif 4859 gl_define_procedure(gluLoadSamplingMatrices, gxg_gluLoadSamplingMatrices_w, 4, 0, 0, H_gluLoadSamplingMatrices, pl_t); 4860 gl_define_procedure(gluLookAt, gxg_gluLookAt_w, 0, 0, 1, H_gluLookAt, pl_tr); 4861 gl_define_procedure(gluNewNurbsRenderer, gxg_gluNewNurbsRenderer_w, 0, 0, 0, H_gluNewNurbsRenderer, pl_t); 4862 gl_define_procedure(gluNewQuadric, gxg_gluNewQuadric_w, 0, 0, 0, H_gluNewQuadric, pl_t); 4863 #ifdef GLU_VERSION_1_2 4864 gl_define_procedure(gluNewTess, gxg_gluNewTess_w, 0, 0, 0, H_gluNewTess, pl_t); 4865 #endif 4866 #ifdef GLU_VERSION_1_2 4867 gl_define_procedure(gluNextContour, gxg_gluNextContour_w, 2, 0, 0, H_gluNextContour, pl_tti); 4868 #endif 4869 gl_define_procedure(gluNurbsCallback, gxg_gluNurbsCallback_w, 3, 0, 0, H_gluNurbsCallback, pl_ttit); 4870 gl_define_procedure(gluNurbsCallbackData, gxg_gluNurbsCallbackData_w, 2, 0, 0, H_gluNurbsCallbackData, pl_t); 4871 gl_define_procedure(gluNurbsCurve, gxg_gluNurbsCurve_w, 7, 0, 0, H_gluNurbsCurve, pl_ttititi); 4872 gl_define_procedure(gluNurbsProperty, gxg_gluNurbsProperty_w, 3, 0, 0, H_gluNurbsProperty, pl_ttir); 4873 gl_define_procedure(gluNurbsSurface, gxg_gluNurbsSurface_w, 0, 0, 1, H_gluNurbsSurface, pl_ttititiiti); 4874 gl_define_procedure(gluOrtho2D, gxg_gluOrtho2D_w, 4, 0, 0, H_gluOrtho2D, pl_tr); 4875 gl_define_procedure(gluPartialDisk, gxg_gluPartialDisk_w, 7, 0, 0, H_gluPartialDisk, pl_ttrriir); 4876 gl_define_procedure(gluPerspective, gxg_gluPerspective_w, 4, 0, 0, H_gluPerspective, pl_tr); 4877 gl_define_procedure(gluPickMatrix, gxg_gluPickMatrix_w, 5, 0, 0, H_gluPickMatrix, pl_trrrrt); 4878 gl_define_procedure(gluProject, gxg_gluProject_w, 0, 0, 1, H_gluProject, pl_prrrt); 4879 gl_define_procedure(gluPwlCurve, gxg_gluPwlCurve_w, 5, 0, 0, H_gluPwlCurve, pl_ttiti); 4880 gl_define_procedure(gluQuadricCallback, gxg_gluQuadricCallback_w, 3, 0, 0, H_gluQuadricCallback, pl_ttit); 4881 gl_define_procedure(gluQuadricDrawStyle, gxg_gluQuadricDrawStyle_w, 2, 0, 0, H_gluQuadricDrawStyle, pl_tti); 4882 gl_define_procedure(gluQuadricNormals, gxg_gluQuadricNormals_w, 2, 0, 0, H_gluQuadricNormals, pl_tti); 4883 gl_define_procedure(gluQuadricOrientation, gxg_gluQuadricOrientation_w, 2, 0, 0, H_gluQuadricOrientation, pl_tti); 4884 gl_define_procedure(gluQuadricTexture, gxg_gluQuadricTexture_w, 2, 0, 0, H_gluQuadricTexture, pl_ttb); 4885 gl_define_procedure(gluScaleImage, gxg_gluScaleImage_w, 0, 0, 1, H_gluScaleImage, pl_iiiiitiiit); 4886 gl_define_procedure(gluSphere, gxg_gluSphere_w, 4, 0, 0, H_gluSphere, pl_ttri); 4887 #ifdef GLU_VERSION_1_2 4888 gl_define_procedure(gluTessBeginContour, gxg_gluTessBeginContour_w, 1, 0, 0, H_gluTessBeginContour, pl_t); 4889 #endif 4890 #ifdef GLU_VERSION_1_2 4891 gl_define_procedure(gluTessBeginPolygon, gxg_gluTessBeginPolygon_w, 2, 0, 0, H_gluTessBeginPolygon, pl_t); 4892 #endif 4893 gl_define_procedure(gluTessCallback, gxg_gluTessCallback_w, 3, 0, 0, H_gluTessCallback, pl_ttit); 4894 #ifdef GLU_VERSION_1_2 4895 gl_define_procedure(gluTessEndContour, gxg_gluTessEndContour_w, 1, 0, 0, H_gluTessEndContour, pl_t); 4896 #endif 4897 #ifdef GLU_VERSION_1_2 4898 gl_define_procedure(gluTessEndPolygon, gxg_gluTessEndPolygon_w, 1, 0, 0, H_gluTessEndPolygon, pl_t); 4899 #endif 4900 #ifdef GLU_VERSION_1_2 4901 gl_define_procedure(gluTessNormal, gxg_gluTessNormal_w, 4, 0, 0, H_gluTessNormal, pl_ttr); 4902 #endif 4903 #ifdef GLU_VERSION_1_2 4904 gl_define_procedure(gluTessProperty, gxg_gluTessProperty_w, 3, 0, 0, H_gluTessProperty, pl_ttir); 4905 #endif 4906 #ifdef GLU_VERSION_1_2 4907 gl_define_procedure(gluTessVertex, gxg_gluTessVertex_w, 3, 0, 0, H_gluTessVertex, pl_t); 4908 #endif 4909 gl_define_procedure(gluUnProject, gxg_gluUnProject_w, 0, 0, 1, H_gluUnProject, pl_prrrt); 4910 gl_define_procedure(gluUnProject4, gxg_gluUnProject4_w, 0, 0, 1, H_gluUnProject4, pl_prrrrtttrrt); 4911 #endif 4912 } 4913 4914 /* ---------------------------------------- constants ---------------------------------------- */ 4915 4916 static void define_integers(void) 4917 { 4918 4919 #define DEFINE_INTEGER(Name) Xen_define(XL_PRE #Name XL_POST, C_int_to_Xen_integer(Name)) 4920 4921 #if USE_MOTIF 4922 DEFINE_INTEGER(GLX_USE_GL); 4923 DEFINE_INTEGER(GLX_BUFFER_SIZE); 4924 DEFINE_INTEGER(GLX_LEVEL); 4925 DEFINE_INTEGER(GLX_RGBA); 4926 DEFINE_INTEGER(GLX_DOUBLEBUFFER); 4927 DEFINE_INTEGER(GLX_STEREO); 4928 DEFINE_INTEGER(GLX_AUX_BUFFERS); 4929 DEFINE_INTEGER(GLX_RED_SIZE); 4930 DEFINE_INTEGER(GLX_GREEN_SIZE); 4931 DEFINE_INTEGER(GLX_BLUE_SIZE); 4932 DEFINE_INTEGER(GLX_ALPHA_SIZE); 4933 DEFINE_INTEGER(GLX_DEPTH_SIZE); 4934 DEFINE_INTEGER(GLX_STENCIL_SIZE); 4935 DEFINE_INTEGER(GLX_ACCUM_RED_SIZE); 4936 DEFINE_INTEGER(GLX_ACCUM_GREEN_SIZE); 4937 DEFINE_INTEGER(GLX_ACCUM_BLUE_SIZE); 4938 DEFINE_INTEGER(GLX_ACCUM_ALPHA_SIZE); 4939 DEFINE_INTEGER(GLX_BAD_SCREEN); 4940 DEFINE_INTEGER(GLX_BAD_ATTRIBUTE); 4941 DEFINE_INTEGER(GLX_NO_EXTENSION); 4942 DEFINE_INTEGER(GLX_BAD_VISUAL); 4943 DEFINE_INTEGER(GLX_BAD_CONTEXT); 4944 DEFINE_INTEGER(GLX_BAD_VALUE); 4945 DEFINE_INTEGER(GLX_BAD_ENUM); 4946 DEFINE_INTEGER(GLX_VENDOR); 4947 DEFINE_INTEGER(GLX_VERSION); 4948 DEFINE_INTEGER(GLX_EXTENSIONS); 4949 #endif 4950 DEFINE_INTEGER(GL_FALSE); 4951 DEFINE_INTEGER(GL_TRUE); 4952 DEFINE_INTEGER(GL_BYTE); 4953 DEFINE_INTEGER(GL_UNSIGNED_BYTE); 4954 DEFINE_INTEGER(GL_SHORT); 4955 DEFINE_INTEGER(GL_UNSIGNED_SHORT); 4956 DEFINE_INTEGER(GL_INT); 4957 DEFINE_INTEGER(GL_UNSIGNED_INT); 4958 DEFINE_INTEGER(GL_FLOAT); 4959 DEFINE_INTEGER(GL_DOUBLE); 4960 DEFINE_INTEGER(GL_2_BYTES); 4961 DEFINE_INTEGER(GL_3_BYTES); 4962 DEFINE_INTEGER(GL_4_BYTES); 4963 DEFINE_INTEGER(GL_POINTS); 4964 DEFINE_INTEGER(GL_LINES); 4965 DEFINE_INTEGER(GL_LINE_LOOP); 4966 DEFINE_INTEGER(GL_LINE_STRIP); 4967 DEFINE_INTEGER(GL_TRIANGLES); 4968 DEFINE_INTEGER(GL_TRIANGLE_STRIP); 4969 DEFINE_INTEGER(GL_TRIANGLE_FAN); 4970 DEFINE_INTEGER(GL_QUADS); 4971 DEFINE_INTEGER(GL_QUAD_STRIP); 4972 DEFINE_INTEGER(GL_POLYGON); 4973 DEFINE_INTEGER(GL_VERTEX_ARRAY); 4974 DEFINE_INTEGER(GL_NORMAL_ARRAY); 4975 DEFINE_INTEGER(GL_COLOR_ARRAY); 4976 DEFINE_INTEGER(GL_INDEX_ARRAY); 4977 DEFINE_INTEGER(GL_TEXTURE_COORD_ARRAY); 4978 DEFINE_INTEGER(GL_EDGE_FLAG_ARRAY); 4979 DEFINE_INTEGER(GL_VERTEX_ARRAY_SIZE); 4980 DEFINE_INTEGER(GL_VERTEX_ARRAY_TYPE); 4981 DEFINE_INTEGER(GL_VERTEX_ARRAY_STRIDE); 4982 DEFINE_INTEGER(GL_NORMAL_ARRAY_TYPE); 4983 DEFINE_INTEGER(GL_NORMAL_ARRAY_STRIDE); 4984 DEFINE_INTEGER(GL_COLOR_ARRAY_SIZE); 4985 DEFINE_INTEGER(GL_COLOR_ARRAY_TYPE); 4986 DEFINE_INTEGER(GL_COLOR_ARRAY_STRIDE); 4987 DEFINE_INTEGER(GL_INDEX_ARRAY_TYPE); 4988 DEFINE_INTEGER(GL_INDEX_ARRAY_STRIDE); 4989 DEFINE_INTEGER(GL_TEXTURE_COORD_ARRAY_SIZE); 4990 DEFINE_INTEGER(GL_TEXTURE_COORD_ARRAY_TYPE); 4991 DEFINE_INTEGER(GL_TEXTURE_COORD_ARRAY_STRIDE); 4992 DEFINE_INTEGER(GL_EDGE_FLAG_ARRAY_STRIDE); 4993 DEFINE_INTEGER(GL_VERTEX_ARRAY_POINTER); 4994 DEFINE_INTEGER(GL_NORMAL_ARRAY_POINTER); 4995 DEFINE_INTEGER(GL_COLOR_ARRAY_POINTER); 4996 DEFINE_INTEGER(GL_INDEX_ARRAY_POINTER); 4997 DEFINE_INTEGER(GL_TEXTURE_COORD_ARRAY_POINTER); 4998 DEFINE_INTEGER(GL_EDGE_FLAG_ARRAY_POINTER); 4999 DEFINE_INTEGER(GL_V2F); 5000 DEFINE_INTEGER(GL_V3F); 5001 DEFINE_INTEGER(GL_C4UB_V2F); 5002 DEFINE_INTEGER(GL_C4UB_V3F); 5003 DEFINE_INTEGER(GL_C3F_V3F); 5004 DEFINE_INTEGER(GL_N3F_V3F); 5005 DEFINE_INTEGER(GL_C4F_N3F_V3F); 5006 DEFINE_INTEGER(GL_T2F_V3F); 5007 DEFINE_INTEGER(GL_T4F_V4F); 5008 DEFINE_INTEGER(GL_T2F_C4UB_V3F); 5009 DEFINE_INTEGER(GL_T2F_C3F_V3F); 5010 DEFINE_INTEGER(GL_T2F_N3F_V3F); 5011 DEFINE_INTEGER(GL_T2F_C4F_N3F_V3F); 5012 DEFINE_INTEGER(GL_T4F_C4F_N3F_V4F); 5013 DEFINE_INTEGER(GL_MATRIX_MODE); 5014 DEFINE_INTEGER(GL_MODELVIEW); 5015 DEFINE_INTEGER(GL_PROJECTION); 5016 DEFINE_INTEGER(GL_TEXTURE); 5017 DEFINE_INTEGER(GL_POINT_SMOOTH); 5018 DEFINE_INTEGER(GL_POINT_SIZE); 5019 DEFINE_INTEGER(GL_POINT_SIZE_GRANULARITY); 5020 DEFINE_INTEGER(GL_POINT_SIZE_RANGE); 5021 DEFINE_INTEGER(GL_LINE_SMOOTH); 5022 DEFINE_INTEGER(GL_LINE_STIPPLE); 5023 DEFINE_INTEGER(GL_LINE_STIPPLE_PATTERN); 5024 DEFINE_INTEGER(GL_LINE_STIPPLE_REPEAT); 5025 DEFINE_INTEGER(GL_LINE_WIDTH); 5026 DEFINE_INTEGER(GL_LINE_WIDTH_GRANULARITY); 5027 DEFINE_INTEGER(GL_LINE_WIDTH_RANGE); 5028 DEFINE_INTEGER(GL_POINT); 5029 DEFINE_INTEGER(GL_LINE); 5030 DEFINE_INTEGER(GL_FILL); 5031 DEFINE_INTEGER(GL_CW); 5032 DEFINE_INTEGER(GL_CCW); 5033 DEFINE_INTEGER(GL_FRONT); 5034 DEFINE_INTEGER(GL_BACK); 5035 DEFINE_INTEGER(GL_POLYGON_MODE); 5036 DEFINE_INTEGER(GL_POLYGON_SMOOTH); 5037 DEFINE_INTEGER(GL_POLYGON_STIPPLE); 5038 DEFINE_INTEGER(GL_EDGE_FLAG); 5039 DEFINE_INTEGER(GL_CULL_FACE); 5040 DEFINE_INTEGER(GL_CULL_FACE_MODE); 5041 DEFINE_INTEGER(GL_FRONT_FACE); 5042 DEFINE_INTEGER(GL_POLYGON_OFFSET_FACTOR); 5043 DEFINE_INTEGER(GL_POLYGON_OFFSET_UNITS); 5044 DEFINE_INTEGER(GL_POLYGON_OFFSET_POINT); 5045 DEFINE_INTEGER(GL_POLYGON_OFFSET_LINE); 5046 DEFINE_INTEGER(GL_POLYGON_OFFSET_FILL); 5047 DEFINE_INTEGER(GL_COMPILE); 5048 DEFINE_INTEGER(GL_COMPILE_AND_EXECUTE); 5049 DEFINE_INTEGER(GL_LIST_BASE); 5050 DEFINE_INTEGER(GL_LIST_INDEX); 5051 DEFINE_INTEGER(GL_LIST_MODE); 5052 DEFINE_INTEGER(GL_NEVER); 5053 DEFINE_INTEGER(GL_LESS); 5054 DEFINE_INTEGER(GL_EQUAL); 5055 DEFINE_INTEGER(GL_LEQUAL); 5056 DEFINE_INTEGER(GL_GREATER); 5057 DEFINE_INTEGER(GL_NOTEQUAL); 5058 DEFINE_INTEGER(GL_GEQUAL); 5059 DEFINE_INTEGER(GL_ALWAYS); 5060 DEFINE_INTEGER(GL_DEPTH_TEST); 5061 DEFINE_INTEGER(GL_DEPTH_BITS); 5062 DEFINE_INTEGER(GL_DEPTH_CLEAR_VALUE); 5063 DEFINE_INTEGER(GL_DEPTH_FUNC); 5064 DEFINE_INTEGER(GL_DEPTH_RANGE); 5065 DEFINE_INTEGER(GL_DEPTH_WRITEMASK); 5066 DEFINE_INTEGER(GL_DEPTH_COMPONENT); 5067 DEFINE_INTEGER(GL_LIGHTING); 5068 DEFINE_INTEGER(GL_LIGHT0); 5069 DEFINE_INTEGER(GL_LIGHT1); 5070 DEFINE_INTEGER(GL_LIGHT2); 5071 DEFINE_INTEGER(GL_LIGHT3); 5072 DEFINE_INTEGER(GL_LIGHT4); 5073 DEFINE_INTEGER(GL_LIGHT5); 5074 DEFINE_INTEGER(GL_LIGHT6); 5075 DEFINE_INTEGER(GL_LIGHT7); 5076 DEFINE_INTEGER(GL_SPOT_EXPONENT); 5077 DEFINE_INTEGER(GL_SPOT_CUTOFF); 5078 DEFINE_INTEGER(GL_CONSTANT_ATTENUATION); 5079 DEFINE_INTEGER(GL_LINEAR_ATTENUATION); 5080 DEFINE_INTEGER(GL_QUADRATIC_ATTENUATION); 5081 DEFINE_INTEGER(GL_AMBIENT); 5082 DEFINE_INTEGER(GL_DIFFUSE); 5083 DEFINE_INTEGER(GL_SPECULAR); 5084 DEFINE_INTEGER(GL_SHININESS); 5085 DEFINE_INTEGER(GL_EMISSION); 5086 DEFINE_INTEGER(GL_POSITION); 5087 DEFINE_INTEGER(GL_SPOT_DIRECTION); 5088 DEFINE_INTEGER(GL_AMBIENT_AND_DIFFUSE); 5089 DEFINE_INTEGER(GL_COLOR_INDEXES); 5090 DEFINE_INTEGER(GL_LIGHT_MODEL_TWO_SIDE); 5091 DEFINE_INTEGER(GL_LIGHT_MODEL_LOCAL_VIEWER); 5092 DEFINE_INTEGER(GL_LIGHT_MODEL_AMBIENT); 5093 DEFINE_INTEGER(GL_FRONT_AND_BACK); 5094 DEFINE_INTEGER(GL_SHADE_MODEL); 5095 DEFINE_INTEGER(GL_FLAT); 5096 DEFINE_INTEGER(GL_SMOOTH); 5097 DEFINE_INTEGER(GL_COLOR_MATERIAL); 5098 DEFINE_INTEGER(GL_COLOR_MATERIAL_FACE); 5099 DEFINE_INTEGER(GL_COLOR_MATERIAL_PARAMETER); 5100 DEFINE_INTEGER(GL_NORMALIZE); 5101 DEFINE_INTEGER(GL_CLIP_PLANE0); 5102 DEFINE_INTEGER(GL_CLIP_PLANE1); 5103 DEFINE_INTEGER(GL_CLIP_PLANE2); 5104 DEFINE_INTEGER(GL_CLIP_PLANE3); 5105 DEFINE_INTEGER(GL_CLIP_PLANE4); 5106 DEFINE_INTEGER(GL_CLIP_PLANE5); 5107 DEFINE_INTEGER(GL_ACCUM_RED_BITS); 5108 DEFINE_INTEGER(GL_ACCUM_GREEN_BITS); 5109 DEFINE_INTEGER(GL_ACCUM_BLUE_BITS); 5110 DEFINE_INTEGER(GL_ACCUM_ALPHA_BITS); 5111 DEFINE_INTEGER(GL_ACCUM_CLEAR_VALUE); 5112 DEFINE_INTEGER(GL_ACCUM); 5113 DEFINE_INTEGER(GL_ADD); 5114 DEFINE_INTEGER(GL_LOAD); 5115 DEFINE_INTEGER(GL_MULT); 5116 DEFINE_INTEGER(GL_RETURN); 5117 DEFINE_INTEGER(GL_ALPHA_TEST); 5118 DEFINE_INTEGER(GL_ALPHA_TEST_REF); 5119 DEFINE_INTEGER(GL_ALPHA_TEST_FUNC); 5120 DEFINE_INTEGER(GL_BLEND); 5121 DEFINE_INTEGER(GL_BLEND_SRC); 5122 DEFINE_INTEGER(GL_BLEND_DST); 5123 DEFINE_INTEGER(GL_ZERO); 5124 DEFINE_INTEGER(GL_ONE); 5125 DEFINE_INTEGER(GL_SRC_COLOR); 5126 DEFINE_INTEGER(GL_ONE_MINUS_SRC_COLOR); 5127 DEFINE_INTEGER(GL_DST_COLOR); 5128 DEFINE_INTEGER(GL_ONE_MINUS_DST_COLOR); 5129 DEFINE_INTEGER(GL_SRC_ALPHA); 5130 DEFINE_INTEGER(GL_ONE_MINUS_SRC_ALPHA); 5131 DEFINE_INTEGER(GL_DST_ALPHA); 5132 DEFINE_INTEGER(GL_ONE_MINUS_DST_ALPHA); 5133 DEFINE_INTEGER(GL_SRC_ALPHA_SATURATE); 5134 DEFINE_INTEGER(GL_CONSTANT_COLOR); 5135 DEFINE_INTEGER(GL_ONE_MINUS_CONSTANT_COLOR); 5136 DEFINE_INTEGER(GL_CONSTANT_ALPHA); 5137 DEFINE_INTEGER(GL_ONE_MINUS_CONSTANT_ALPHA); 5138 DEFINE_INTEGER(GL_FEEDBACK); 5139 DEFINE_INTEGER(GL_RENDER); 5140 DEFINE_INTEGER(GL_SELECT); 5141 DEFINE_INTEGER(GL_2D); 5142 DEFINE_INTEGER(GL_3D); 5143 DEFINE_INTEGER(GL_3D_COLOR); 5144 DEFINE_INTEGER(GL_3D_COLOR_TEXTURE); 5145 DEFINE_INTEGER(GL_4D_COLOR_TEXTURE); 5146 DEFINE_INTEGER(GL_POINT_TOKEN); 5147 DEFINE_INTEGER(GL_LINE_TOKEN); 5148 DEFINE_INTEGER(GL_LINE_RESET_TOKEN); 5149 DEFINE_INTEGER(GL_POLYGON_TOKEN); 5150 DEFINE_INTEGER(GL_BITMAP_TOKEN); 5151 DEFINE_INTEGER(GL_DRAW_PIXEL_TOKEN); 5152 DEFINE_INTEGER(GL_COPY_PIXEL_TOKEN); 5153 DEFINE_INTEGER(GL_PASS_THROUGH_TOKEN); 5154 DEFINE_INTEGER(GL_FEEDBACK_BUFFER_POINTER); 5155 DEFINE_INTEGER(GL_FEEDBACK_BUFFER_SIZE); 5156 DEFINE_INTEGER(GL_FEEDBACK_BUFFER_TYPE); 5157 DEFINE_INTEGER(GL_SELECTION_BUFFER_POINTER); 5158 DEFINE_INTEGER(GL_SELECTION_BUFFER_SIZE); 5159 DEFINE_INTEGER(GL_FOG); 5160 DEFINE_INTEGER(GL_FOG_MODE); 5161 DEFINE_INTEGER(GL_FOG_DENSITY); 5162 DEFINE_INTEGER(GL_FOG_COLOR); 5163 DEFINE_INTEGER(GL_FOG_INDEX); 5164 DEFINE_INTEGER(GL_FOG_START); 5165 DEFINE_INTEGER(GL_FOG_END); 5166 DEFINE_INTEGER(GL_LINEAR); 5167 DEFINE_INTEGER(GL_EXP); 5168 DEFINE_INTEGER(GL_EXP2); 5169 DEFINE_INTEGER(GL_LOGIC_OP); 5170 DEFINE_INTEGER(GL_INDEX_LOGIC_OP); 5171 DEFINE_INTEGER(GL_COLOR_LOGIC_OP); 5172 DEFINE_INTEGER(GL_LOGIC_OP_MODE); 5173 DEFINE_INTEGER(GL_CLEAR); 5174 DEFINE_INTEGER(GL_SET); 5175 DEFINE_INTEGER(GL_COPY); 5176 DEFINE_INTEGER(GL_COPY_INVERTED); 5177 DEFINE_INTEGER(GL_NOOP); 5178 DEFINE_INTEGER(GL_INVERT); 5179 DEFINE_INTEGER(GL_AND); 5180 DEFINE_INTEGER(GL_NAND); 5181 DEFINE_INTEGER(GL_OR); 5182 DEFINE_INTEGER(GL_NOR); 5183 DEFINE_INTEGER(GL_XOR); 5184 DEFINE_INTEGER(GL_EQUIV); 5185 DEFINE_INTEGER(GL_AND_REVERSE); 5186 DEFINE_INTEGER(GL_AND_INVERTED); 5187 DEFINE_INTEGER(GL_OR_REVERSE); 5188 DEFINE_INTEGER(GL_OR_INVERTED); 5189 DEFINE_INTEGER(GL_STENCIL_TEST); 5190 DEFINE_INTEGER(GL_STENCIL_WRITEMASK); 5191 DEFINE_INTEGER(GL_STENCIL_BITS); 5192 DEFINE_INTEGER(GL_STENCIL_FUNC); 5193 DEFINE_INTEGER(GL_STENCIL_VALUE_MASK); 5194 DEFINE_INTEGER(GL_STENCIL_REF); 5195 DEFINE_INTEGER(GL_STENCIL_FAIL); 5196 DEFINE_INTEGER(GL_STENCIL_PASS_DEPTH_PASS); 5197 DEFINE_INTEGER(GL_STENCIL_PASS_DEPTH_FAIL); 5198 DEFINE_INTEGER(GL_STENCIL_CLEAR_VALUE); 5199 DEFINE_INTEGER(GL_STENCIL_INDEX); 5200 DEFINE_INTEGER(GL_KEEP); 5201 DEFINE_INTEGER(GL_REPLACE); 5202 DEFINE_INTEGER(GL_INCR); 5203 DEFINE_INTEGER(GL_DECR); 5204 DEFINE_INTEGER(GL_NONE); 5205 DEFINE_INTEGER(GL_LEFT); 5206 DEFINE_INTEGER(GL_RIGHT); 5207 DEFINE_INTEGER(GL_FRONT_LEFT); 5208 DEFINE_INTEGER(GL_FRONT_RIGHT); 5209 DEFINE_INTEGER(GL_BACK_LEFT); 5210 DEFINE_INTEGER(GL_BACK_RIGHT); 5211 DEFINE_INTEGER(GL_AUX0); 5212 DEFINE_INTEGER(GL_AUX1); 5213 DEFINE_INTEGER(GL_AUX2); 5214 DEFINE_INTEGER(GL_AUX3); 5215 DEFINE_INTEGER(GL_COLOR_INDEX); 5216 DEFINE_INTEGER(GL_RED); 5217 DEFINE_INTEGER(GL_GREEN); 5218 DEFINE_INTEGER(GL_BLUE); 5219 DEFINE_INTEGER(GL_ALPHA); 5220 DEFINE_INTEGER(GL_LUMINANCE); 5221 DEFINE_INTEGER(GL_LUMINANCE_ALPHA); 5222 DEFINE_INTEGER(GL_ALPHA_BITS); 5223 DEFINE_INTEGER(GL_RED_BITS); 5224 DEFINE_INTEGER(GL_GREEN_BITS); 5225 DEFINE_INTEGER(GL_BLUE_BITS); 5226 DEFINE_INTEGER(GL_INDEX_BITS); 5227 DEFINE_INTEGER(GL_SUBPIXEL_BITS); 5228 DEFINE_INTEGER(GL_AUX_BUFFERS); 5229 DEFINE_INTEGER(GL_READ_BUFFER); 5230 DEFINE_INTEGER(GL_DRAW_BUFFER); 5231 DEFINE_INTEGER(GL_DOUBLEBUFFER); 5232 DEFINE_INTEGER(GL_STEREO); 5233 DEFINE_INTEGER(GL_BITMAP); 5234 DEFINE_INTEGER(GL_COLOR); 5235 DEFINE_INTEGER(GL_DEPTH); 5236 DEFINE_INTEGER(GL_STENCIL); 5237 DEFINE_INTEGER(GL_DITHER); 5238 DEFINE_INTEGER(GL_RGB); 5239 DEFINE_INTEGER(GL_RGBA); 5240 DEFINE_INTEGER(GL_MAX_LIST_NESTING); 5241 DEFINE_INTEGER(GL_MAX_ATTRIB_STACK_DEPTH); 5242 DEFINE_INTEGER(GL_MAX_MODELVIEW_STACK_DEPTH); 5243 DEFINE_INTEGER(GL_MAX_NAME_STACK_DEPTH); 5244 DEFINE_INTEGER(GL_MAX_PROJECTION_STACK_DEPTH); 5245 DEFINE_INTEGER(GL_MAX_TEXTURE_STACK_DEPTH); 5246 DEFINE_INTEGER(GL_MAX_EVAL_ORDER); 5247 DEFINE_INTEGER(GL_MAX_LIGHTS); 5248 DEFINE_INTEGER(GL_MAX_CLIP_PLANES); 5249 DEFINE_INTEGER(GL_MAX_TEXTURE_SIZE); 5250 DEFINE_INTEGER(GL_MAX_PIXEL_MAP_TABLE); 5251 DEFINE_INTEGER(GL_MAX_VIEWPORT_DIMS); 5252 DEFINE_INTEGER(GL_MAX_CLIENT_ATTRIB_STACK_DEPTH); 5253 DEFINE_INTEGER(GL_ATTRIB_STACK_DEPTH); 5254 DEFINE_INTEGER(GL_CLIENT_ATTRIB_STACK_DEPTH); 5255 DEFINE_INTEGER(GL_COLOR_CLEAR_VALUE); 5256 DEFINE_INTEGER(GL_COLOR_WRITEMASK); 5257 DEFINE_INTEGER(GL_CURRENT_INDEX); 5258 DEFINE_INTEGER(GL_CURRENT_COLOR); 5259 DEFINE_INTEGER(GL_CURRENT_NORMAL); 5260 DEFINE_INTEGER(GL_CURRENT_RASTER_COLOR); 5261 DEFINE_INTEGER(GL_CURRENT_RASTER_DISTANCE); 5262 DEFINE_INTEGER(GL_CURRENT_RASTER_INDEX); 5263 DEFINE_INTEGER(GL_CURRENT_RASTER_POSITION); 5264 DEFINE_INTEGER(GL_CURRENT_RASTER_TEXTURE_COORDS); 5265 DEFINE_INTEGER(GL_CURRENT_RASTER_POSITION_VALID); 5266 DEFINE_INTEGER(GL_CURRENT_TEXTURE_COORDS); 5267 DEFINE_INTEGER(GL_INDEX_CLEAR_VALUE); 5268 DEFINE_INTEGER(GL_INDEX_MODE); 5269 DEFINE_INTEGER(GL_INDEX_WRITEMASK); 5270 DEFINE_INTEGER(GL_MODELVIEW_MATRIX); 5271 DEFINE_INTEGER(GL_MODELVIEW_STACK_DEPTH); 5272 DEFINE_INTEGER(GL_NAME_STACK_DEPTH); 5273 DEFINE_INTEGER(GL_PROJECTION_MATRIX); 5274 DEFINE_INTEGER(GL_PROJECTION_STACK_DEPTH); 5275 DEFINE_INTEGER(GL_RENDER_MODE); 5276 DEFINE_INTEGER(GL_RGBA_MODE); 5277 DEFINE_INTEGER(GL_TEXTURE_MATRIX); 5278 DEFINE_INTEGER(GL_TEXTURE_STACK_DEPTH); 5279 DEFINE_INTEGER(GL_VIEWPORT); 5280 DEFINE_INTEGER(GL_AUTO_NORMAL); 5281 DEFINE_INTEGER(GL_MAP1_COLOR_4); 5282 DEFINE_INTEGER(GL_MAP1_GRID_DOMAIN); 5283 DEFINE_INTEGER(GL_MAP1_GRID_SEGMENTS); 5284 DEFINE_INTEGER(GL_MAP1_INDEX); 5285 DEFINE_INTEGER(GL_MAP1_NORMAL); 5286 DEFINE_INTEGER(GL_MAP1_TEXTURE_COORD_1); 5287 DEFINE_INTEGER(GL_MAP1_TEXTURE_COORD_2); 5288 DEFINE_INTEGER(GL_MAP1_TEXTURE_COORD_3); 5289 DEFINE_INTEGER(GL_MAP1_TEXTURE_COORD_4); 5290 DEFINE_INTEGER(GL_MAP1_VERTEX_3); 5291 DEFINE_INTEGER(GL_MAP1_VERTEX_4); 5292 DEFINE_INTEGER(GL_MAP2_COLOR_4); 5293 DEFINE_INTEGER(GL_MAP2_GRID_DOMAIN); 5294 DEFINE_INTEGER(GL_MAP2_GRID_SEGMENTS); 5295 DEFINE_INTEGER(GL_MAP2_INDEX); 5296 DEFINE_INTEGER(GL_MAP2_NORMAL); 5297 DEFINE_INTEGER(GL_MAP2_TEXTURE_COORD_1); 5298 DEFINE_INTEGER(GL_MAP2_TEXTURE_COORD_2); 5299 DEFINE_INTEGER(GL_MAP2_TEXTURE_COORD_3); 5300 DEFINE_INTEGER(GL_MAP2_TEXTURE_COORD_4); 5301 DEFINE_INTEGER(GL_MAP2_VERTEX_3); 5302 DEFINE_INTEGER(GL_MAP2_VERTEX_4); 5303 DEFINE_INTEGER(GL_COEFF); 5304 DEFINE_INTEGER(GL_DOMAIN); 5305 DEFINE_INTEGER(GL_ORDER); 5306 DEFINE_INTEGER(GL_FOG_HINT); 5307 DEFINE_INTEGER(GL_LINE_SMOOTH_HINT); 5308 DEFINE_INTEGER(GL_PERSPECTIVE_CORRECTION_HINT); 5309 DEFINE_INTEGER(GL_POINT_SMOOTH_HINT); 5310 DEFINE_INTEGER(GL_POLYGON_SMOOTH_HINT); 5311 DEFINE_INTEGER(GL_DONT_CARE); 5312 DEFINE_INTEGER(GL_FASTEST); 5313 DEFINE_INTEGER(GL_NICEST); 5314 DEFINE_INTEGER(GL_SCISSOR_TEST); 5315 DEFINE_INTEGER(GL_SCISSOR_BOX); 5316 DEFINE_INTEGER(GL_MAP_COLOR); 5317 DEFINE_INTEGER(GL_MAP_STENCIL); 5318 DEFINE_INTEGER(GL_INDEX_SHIFT); 5319 DEFINE_INTEGER(GL_INDEX_OFFSET); 5320 DEFINE_INTEGER(GL_RED_SCALE); 5321 DEFINE_INTEGER(GL_RED_BIAS); 5322 DEFINE_INTEGER(GL_GREEN_SCALE); 5323 DEFINE_INTEGER(GL_GREEN_BIAS); 5324 DEFINE_INTEGER(GL_BLUE_SCALE); 5325 DEFINE_INTEGER(GL_BLUE_BIAS); 5326 DEFINE_INTEGER(GL_ALPHA_SCALE); 5327 DEFINE_INTEGER(GL_ALPHA_BIAS); 5328 DEFINE_INTEGER(GL_DEPTH_SCALE); 5329 DEFINE_INTEGER(GL_DEPTH_BIAS); 5330 DEFINE_INTEGER(GL_PIXEL_MAP_S_TO_S_SIZE); 5331 DEFINE_INTEGER(GL_PIXEL_MAP_I_TO_I_SIZE); 5332 DEFINE_INTEGER(GL_PIXEL_MAP_I_TO_R_SIZE); 5333 DEFINE_INTEGER(GL_PIXEL_MAP_I_TO_G_SIZE); 5334 DEFINE_INTEGER(GL_PIXEL_MAP_I_TO_B_SIZE); 5335 DEFINE_INTEGER(GL_PIXEL_MAP_I_TO_A_SIZE); 5336 DEFINE_INTEGER(GL_PIXEL_MAP_R_TO_R_SIZE); 5337 DEFINE_INTEGER(GL_PIXEL_MAP_G_TO_G_SIZE); 5338 DEFINE_INTEGER(GL_PIXEL_MAP_B_TO_B_SIZE); 5339 DEFINE_INTEGER(GL_PIXEL_MAP_A_TO_A_SIZE); 5340 DEFINE_INTEGER(GL_PIXEL_MAP_S_TO_S); 5341 DEFINE_INTEGER(GL_PIXEL_MAP_I_TO_I); 5342 DEFINE_INTEGER(GL_PIXEL_MAP_I_TO_R); 5343 DEFINE_INTEGER(GL_PIXEL_MAP_I_TO_G); 5344 DEFINE_INTEGER(GL_PIXEL_MAP_I_TO_B); 5345 DEFINE_INTEGER(GL_PIXEL_MAP_I_TO_A); 5346 DEFINE_INTEGER(GL_PIXEL_MAP_R_TO_R); 5347 DEFINE_INTEGER(GL_PIXEL_MAP_G_TO_G); 5348 DEFINE_INTEGER(GL_PIXEL_MAP_B_TO_B); 5349 DEFINE_INTEGER(GL_PIXEL_MAP_A_TO_A); 5350 DEFINE_INTEGER(GL_PACK_ALIGNMENT); 5351 DEFINE_INTEGER(GL_PACK_LSB_FIRST); 5352 DEFINE_INTEGER(GL_PACK_ROW_LENGTH); 5353 DEFINE_INTEGER(GL_PACK_SKIP_PIXELS); 5354 DEFINE_INTEGER(GL_PACK_SKIP_ROWS); 5355 DEFINE_INTEGER(GL_PACK_SWAP_BYTES); 5356 DEFINE_INTEGER(GL_UNPACK_ALIGNMENT); 5357 DEFINE_INTEGER(GL_UNPACK_LSB_FIRST); 5358 DEFINE_INTEGER(GL_UNPACK_ROW_LENGTH); 5359 DEFINE_INTEGER(GL_UNPACK_SKIP_PIXELS); 5360 DEFINE_INTEGER(GL_UNPACK_SKIP_ROWS); 5361 DEFINE_INTEGER(GL_UNPACK_SWAP_BYTES); 5362 DEFINE_INTEGER(GL_ZOOM_X); 5363 DEFINE_INTEGER(GL_ZOOM_Y); 5364 DEFINE_INTEGER(GL_TEXTURE_ENV); 5365 DEFINE_INTEGER(GL_TEXTURE_ENV_MODE); 5366 DEFINE_INTEGER(GL_TEXTURE_1D); 5367 DEFINE_INTEGER(GL_TEXTURE_2D); 5368 DEFINE_INTEGER(GL_TEXTURE_WRAP_S); 5369 DEFINE_INTEGER(GL_TEXTURE_WRAP_T); 5370 DEFINE_INTEGER(GL_TEXTURE_MAG_FILTER); 5371 DEFINE_INTEGER(GL_TEXTURE_MIN_FILTER); 5372 DEFINE_INTEGER(GL_TEXTURE_ENV_COLOR); 5373 DEFINE_INTEGER(GL_TEXTURE_GEN_S); 5374 DEFINE_INTEGER(GL_TEXTURE_GEN_T); 5375 DEFINE_INTEGER(GL_TEXTURE_GEN_MODE); 5376 DEFINE_INTEGER(GL_TEXTURE_BORDER_COLOR); 5377 DEFINE_INTEGER(GL_TEXTURE_WIDTH); 5378 DEFINE_INTEGER(GL_TEXTURE_HEIGHT); 5379 DEFINE_INTEGER(GL_TEXTURE_BORDER); 5380 DEFINE_INTEGER(GL_TEXTURE_COMPONENTS); 5381 DEFINE_INTEGER(GL_TEXTURE_RED_SIZE); 5382 DEFINE_INTEGER(GL_TEXTURE_GREEN_SIZE); 5383 DEFINE_INTEGER(GL_TEXTURE_BLUE_SIZE); 5384 DEFINE_INTEGER(GL_TEXTURE_ALPHA_SIZE); 5385 DEFINE_INTEGER(GL_TEXTURE_LUMINANCE_SIZE); 5386 DEFINE_INTEGER(GL_TEXTURE_INTENSITY_SIZE); 5387 DEFINE_INTEGER(GL_NEAREST_MIPMAP_NEAREST); 5388 DEFINE_INTEGER(GL_NEAREST_MIPMAP_LINEAR); 5389 DEFINE_INTEGER(GL_LINEAR_MIPMAP_NEAREST); 5390 DEFINE_INTEGER(GL_LINEAR_MIPMAP_LINEAR); 5391 DEFINE_INTEGER(GL_OBJECT_LINEAR); 5392 DEFINE_INTEGER(GL_OBJECT_PLANE); 5393 DEFINE_INTEGER(GL_EYE_LINEAR); 5394 DEFINE_INTEGER(GL_EYE_PLANE); 5395 DEFINE_INTEGER(GL_SPHERE_MAP); 5396 DEFINE_INTEGER(GL_DECAL); 5397 DEFINE_INTEGER(GL_MODULATE); 5398 DEFINE_INTEGER(GL_NEAREST); 5399 DEFINE_INTEGER(GL_REPEAT); 5400 DEFINE_INTEGER(GL_CLAMP); 5401 DEFINE_INTEGER(GL_S); 5402 DEFINE_INTEGER(GL_T); 5403 DEFINE_INTEGER(GL_R); 5404 DEFINE_INTEGER(GL_Q); 5405 DEFINE_INTEGER(GL_TEXTURE_GEN_R); 5406 DEFINE_INTEGER(GL_TEXTURE_GEN_Q); 5407 DEFINE_INTEGER(GL_PROXY_TEXTURE_1D); 5408 DEFINE_INTEGER(GL_PROXY_TEXTURE_2D); 5409 DEFINE_INTEGER(GL_TEXTURE_PRIORITY); 5410 DEFINE_INTEGER(GL_TEXTURE_RESIDENT); 5411 DEFINE_INTEGER(GL_TEXTURE_BINDING_1D); 5412 DEFINE_INTEGER(GL_TEXTURE_BINDING_2D); 5413 DEFINE_INTEGER(GL_TEXTURE_INTERNAL_FORMAT); 5414 DEFINE_INTEGER(GL_PACK_SKIP_IMAGES); 5415 DEFINE_INTEGER(GL_PACK_IMAGE_HEIGHT); 5416 DEFINE_INTEGER(GL_UNPACK_SKIP_IMAGES); 5417 DEFINE_INTEGER(GL_UNPACK_IMAGE_HEIGHT); 5418 DEFINE_INTEGER(GL_TEXTURE_3D); 5419 DEFINE_INTEGER(GL_PROXY_TEXTURE_3D); 5420 DEFINE_INTEGER(GL_TEXTURE_DEPTH); 5421 DEFINE_INTEGER(GL_TEXTURE_WRAP_R); 5422 DEFINE_INTEGER(GL_MAX_3D_TEXTURE_SIZE); 5423 DEFINE_INTEGER(GL_TEXTURE_BINDING_3D); 5424 DEFINE_INTEGER(GL_ALPHA4); 5425 DEFINE_INTEGER(GL_ALPHA8); 5426 DEFINE_INTEGER(GL_ALPHA12); 5427 DEFINE_INTEGER(GL_ALPHA16); 5428 DEFINE_INTEGER(GL_LUMINANCE4); 5429 DEFINE_INTEGER(GL_LUMINANCE8); 5430 DEFINE_INTEGER(GL_LUMINANCE12); 5431 DEFINE_INTEGER(GL_LUMINANCE16); 5432 DEFINE_INTEGER(GL_LUMINANCE4_ALPHA4); 5433 DEFINE_INTEGER(GL_LUMINANCE6_ALPHA2); 5434 DEFINE_INTEGER(GL_LUMINANCE8_ALPHA8); 5435 DEFINE_INTEGER(GL_LUMINANCE12_ALPHA4); 5436 DEFINE_INTEGER(GL_LUMINANCE12_ALPHA12); 5437 DEFINE_INTEGER(GL_LUMINANCE16_ALPHA16); 5438 DEFINE_INTEGER(GL_INTENSITY); 5439 DEFINE_INTEGER(GL_INTENSITY4); 5440 DEFINE_INTEGER(GL_INTENSITY8); 5441 DEFINE_INTEGER(GL_INTENSITY12); 5442 DEFINE_INTEGER(GL_INTENSITY16); 5443 DEFINE_INTEGER(GL_R3_G3_B2); 5444 DEFINE_INTEGER(GL_RGB4); 5445 DEFINE_INTEGER(GL_RGB5); 5446 DEFINE_INTEGER(GL_RGB8); 5447 DEFINE_INTEGER(GL_RGB10); 5448 DEFINE_INTEGER(GL_RGB12); 5449 DEFINE_INTEGER(GL_RGB16); 5450 DEFINE_INTEGER(GL_RGBA2); 5451 DEFINE_INTEGER(GL_RGBA4); 5452 DEFINE_INTEGER(GL_RGB5_A1); 5453 DEFINE_INTEGER(GL_RGBA8); 5454 DEFINE_INTEGER(GL_RGB10_A2); 5455 DEFINE_INTEGER(GL_RGBA12); 5456 DEFINE_INTEGER(GL_RGBA16); 5457 DEFINE_INTEGER(GL_VENDOR); 5458 DEFINE_INTEGER(GL_RENDERER); 5459 DEFINE_INTEGER(GL_VERSION); 5460 DEFINE_INTEGER(GL_EXTENSIONS); 5461 DEFINE_INTEGER(GL_NO_ERROR); 5462 DEFINE_INTEGER(GL_INVALID_VALUE); 5463 DEFINE_INTEGER(GL_INVALID_ENUM); 5464 DEFINE_INTEGER(GL_INVALID_OPERATION); 5465 DEFINE_INTEGER(GL_STACK_OVERFLOW); 5466 DEFINE_INTEGER(GL_STACK_UNDERFLOW); 5467 DEFINE_INTEGER(GL_OUT_OF_MEMORY); 5468 DEFINE_INTEGER(GL_RESCALE_NORMAL); 5469 DEFINE_INTEGER(GL_CLAMP_TO_EDGE); 5470 DEFINE_INTEGER(GL_MAX_ELEMENTS_VERTICES); 5471 DEFINE_INTEGER(GL_MAX_ELEMENTS_INDICES); 5472 DEFINE_INTEGER(GL_BGR); 5473 DEFINE_INTEGER(GL_BGRA); 5474 DEFINE_INTEGER(GL_UNSIGNED_BYTE_3_3_2); 5475 DEFINE_INTEGER(GL_UNSIGNED_BYTE_2_3_3_REV); 5476 DEFINE_INTEGER(GL_UNSIGNED_SHORT_5_6_5); 5477 DEFINE_INTEGER(GL_UNSIGNED_SHORT_5_6_5_REV); 5478 DEFINE_INTEGER(GL_UNSIGNED_SHORT_4_4_4_4); 5479 DEFINE_INTEGER(GL_UNSIGNED_SHORT_4_4_4_4_REV); 5480 DEFINE_INTEGER(GL_UNSIGNED_SHORT_5_5_5_1); 5481 DEFINE_INTEGER(GL_UNSIGNED_SHORT_1_5_5_5_REV); 5482 DEFINE_INTEGER(GL_UNSIGNED_INT_8_8_8_8); 5483 DEFINE_INTEGER(GL_UNSIGNED_INT_8_8_8_8_REV); 5484 DEFINE_INTEGER(GL_UNSIGNED_INT_10_10_10_2); 5485 DEFINE_INTEGER(GL_UNSIGNED_INT_2_10_10_10_REV); 5486 DEFINE_INTEGER(GL_LIGHT_MODEL_COLOR_CONTROL); 5487 DEFINE_INTEGER(GL_SINGLE_COLOR); 5488 DEFINE_INTEGER(GL_SEPARATE_SPECULAR_COLOR); 5489 DEFINE_INTEGER(GL_TEXTURE_MIN_LOD); 5490 DEFINE_INTEGER(GL_TEXTURE_MAX_LOD); 5491 DEFINE_INTEGER(GL_TEXTURE_BASE_LEVEL); 5492 DEFINE_INTEGER(GL_TEXTURE_MAX_LEVEL); 5493 DEFINE_INTEGER(GL_COLOR_TABLE); 5494 DEFINE_INTEGER(GL_POST_CONVOLUTION_COLOR_TABLE); 5495 DEFINE_INTEGER(GL_POST_COLOR_MATRIX_COLOR_TABLE); 5496 DEFINE_INTEGER(GL_PROXY_COLOR_TABLE); 5497 DEFINE_INTEGER(GL_PROXY_POST_CONVOLUTION_COLOR_TABLE); 5498 DEFINE_INTEGER(GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE); 5499 DEFINE_INTEGER(GL_COLOR_TABLE_SCALE); 5500 DEFINE_INTEGER(GL_COLOR_TABLE_BIAS); 5501 DEFINE_INTEGER(GL_COLOR_TABLE_FORMAT); 5502 DEFINE_INTEGER(GL_COLOR_TABLE_WIDTH); 5503 DEFINE_INTEGER(GL_COLOR_TABLE_RED_SIZE); 5504 DEFINE_INTEGER(GL_COLOR_TABLE_GREEN_SIZE); 5505 DEFINE_INTEGER(GL_COLOR_TABLE_BLUE_SIZE); 5506 DEFINE_INTEGER(GL_COLOR_TABLE_ALPHA_SIZE); 5507 DEFINE_INTEGER(GL_COLOR_TABLE_LUMINANCE_SIZE); 5508 DEFINE_INTEGER(GL_COLOR_TABLE_INTENSITY_SIZE); 5509 DEFINE_INTEGER(GL_CONVOLUTION_1D); 5510 DEFINE_INTEGER(GL_CONVOLUTION_2D); 5511 DEFINE_INTEGER(GL_SEPARABLE_2D); 5512 DEFINE_INTEGER(GL_CONVOLUTION_BORDER_MODE); 5513 DEFINE_INTEGER(GL_CONVOLUTION_FILTER_SCALE); 5514 DEFINE_INTEGER(GL_CONVOLUTION_FILTER_BIAS); 5515 DEFINE_INTEGER(GL_REDUCE); 5516 DEFINE_INTEGER(GL_CONVOLUTION_FORMAT); 5517 DEFINE_INTEGER(GL_CONVOLUTION_WIDTH); 5518 DEFINE_INTEGER(GL_CONVOLUTION_HEIGHT); 5519 DEFINE_INTEGER(GL_MAX_CONVOLUTION_WIDTH); 5520 DEFINE_INTEGER(GL_MAX_CONVOLUTION_HEIGHT); 5521 DEFINE_INTEGER(GL_POST_CONVOLUTION_RED_SCALE); 5522 DEFINE_INTEGER(GL_POST_CONVOLUTION_GREEN_SCALE); 5523 DEFINE_INTEGER(GL_POST_CONVOLUTION_BLUE_SCALE); 5524 DEFINE_INTEGER(GL_POST_CONVOLUTION_ALPHA_SCALE); 5525 DEFINE_INTEGER(GL_POST_CONVOLUTION_RED_BIAS); 5526 DEFINE_INTEGER(GL_POST_CONVOLUTION_GREEN_BIAS); 5527 DEFINE_INTEGER(GL_POST_CONVOLUTION_BLUE_BIAS); 5528 DEFINE_INTEGER(GL_POST_CONVOLUTION_ALPHA_BIAS); 5529 DEFINE_INTEGER(GL_CONSTANT_BORDER); 5530 DEFINE_INTEGER(GL_REPLICATE_BORDER); 5531 DEFINE_INTEGER(GL_CONVOLUTION_BORDER_COLOR); 5532 DEFINE_INTEGER(GL_COLOR_MATRIX); 5533 DEFINE_INTEGER(GL_COLOR_MATRIX_STACK_DEPTH); 5534 DEFINE_INTEGER(GL_MAX_COLOR_MATRIX_STACK_DEPTH); 5535 DEFINE_INTEGER(GL_POST_COLOR_MATRIX_RED_SCALE); 5536 DEFINE_INTEGER(GL_POST_COLOR_MATRIX_GREEN_SCALE); 5537 DEFINE_INTEGER(GL_POST_COLOR_MATRIX_BLUE_SCALE); 5538 DEFINE_INTEGER(GL_POST_COLOR_MATRIX_ALPHA_SCALE); 5539 DEFINE_INTEGER(GL_POST_COLOR_MATRIX_RED_BIAS); 5540 DEFINE_INTEGER(GL_POST_COLOR_MATRIX_GREEN_BIAS); 5541 DEFINE_INTEGER(GL_POST_COLOR_MATRIX_BLUE_BIAS); 5542 DEFINE_INTEGER(GL_POST_COLOR_MATRIX_ALPHA_BIAS); 5543 DEFINE_INTEGER(GL_HISTOGRAM); 5544 DEFINE_INTEGER(GL_PROXY_HISTOGRAM); 5545 DEFINE_INTEGER(GL_HISTOGRAM_WIDTH); 5546 DEFINE_INTEGER(GL_HISTOGRAM_FORMAT); 5547 DEFINE_INTEGER(GL_HISTOGRAM_RED_SIZE); 5548 DEFINE_INTEGER(GL_HISTOGRAM_GREEN_SIZE); 5549 DEFINE_INTEGER(GL_HISTOGRAM_BLUE_SIZE); 5550 DEFINE_INTEGER(GL_HISTOGRAM_ALPHA_SIZE); 5551 DEFINE_INTEGER(GL_HISTOGRAM_LUMINANCE_SIZE); 5552 DEFINE_INTEGER(GL_HISTOGRAM_SINK); 5553 DEFINE_INTEGER(GL_MINMAX); 5554 DEFINE_INTEGER(GL_MINMAX_FORMAT); 5555 DEFINE_INTEGER(GL_MINMAX_SINK); 5556 DEFINE_INTEGER(GL_TABLE_TOO_LARGE); 5557 DEFINE_INTEGER(GL_BLEND_EQUATION); 5558 DEFINE_INTEGER(GL_MIN); 5559 DEFINE_INTEGER(GL_MAX); 5560 DEFINE_INTEGER(GL_FUNC_ADD); 5561 DEFINE_INTEGER(GL_FUNC_SUBTRACT); 5562 DEFINE_INTEGER(GL_FUNC_REVERSE_SUBTRACT); 5563 DEFINE_INTEGER(GL_BLEND_COLOR); 5564 DEFINE_INTEGER(GL_CURRENT_BIT); 5565 DEFINE_INTEGER(GL_POINT_BIT); 5566 DEFINE_INTEGER(GL_LINE_BIT); 5567 DEFINE_INTEGER(GL_POLYGON_BIT); 5568 DEFINE_INTEGER(GL_POLYGON_STIPPLE_BIT); 5569 DEFINE_INTEGER(GL_PIXEL_MODE_BIT); 5570 DEFINE_INTEGER(GL_LIGHTING_BIT); 5571 DEFINE_INTEGER(GL_FOG_BIT); 5572 DEFINE_INTEGER(GL_DEPTH_BUFFER_BIT); 5573 DEFINE_INTEGER(GL_ACCUM_BUFFER_BIT); 5574 DEFINE_INTEGER(GL_STENCIL_BUFFER_BIT); 5575 DEFINE_INTEGER(GL_VIEWPORT_BIT); 5576 DEFINE_INTEGER(GL_TRANSFORM_BIT); 5577 DEFINE_INTEGER(GL_ENABLE_BIT); 5578 DEFINE_INTEGER(GL_COLOR_BUFFER_BIT); 5579 DEFINE_INTEGER(GL_HINT_BIT); 5580 DEFINE_INTEGER(GL_EVAL_BIT); 5581 DEFINE_INTEGER(GL_LIST_BIT); 5582 DEFINE_INTEGER(GL_TEXTURE_BIT); 5583 DEFINE_INTEGER(GL_SCISSOR_BIT); 5584 DEFINE_INTEGER(GL_ALL_ATTRIB_BITS); 5585 DEFINE_INTEGER(GL_CLIENT_PIXEL_STORE_BIT); 5586 DEFINE_INTEGER(GL_CLIENT_VERTEX_ARRAY_BIT); 5587 #if HAVE_GLU 5588 DEFINE_INTEGER(GLU_FALSE); 5589 DEFINE_INTEGER(GLU_TRUE); 5590 DEFINE_INTEGER(GLU_VERSION); 5591 DEFINE_INTEGER(GLU_EXTENSIONS); 5592 DEFINE_INTEGER(GLU_INVALID_ENUM); 5593 DEFINE_INTEGER(GLU_INVALID_VALUE); 5594 DEFINE_INTEGER(GLU_OUT_OF_MEMORY); 5595 DEFINE_INTEGER(GLU_INVALID_OPERATION); 5596 DEFINE_INTEGER(GLU_OUTLINE_POLYGON); 5597 DEFINE_INTEGER(GLU_OUTLINE_PATCH); 5598 DEFINE_INTEGER(GLU_NURBS_ERROR); 5599 DEFINE_INTEGER(GLU_ERROR); 5600 DEFINE_INTEGER(GLU_NURBS_BEGIN); 5601 DEFINE_INTEGER(GLU_NURBS_VERTEX); 5602 DEFINE_INTEGER(GLU_NURBS_NORMAL); 5603 DEFINE_INTEGER(GLU_NURBS_COLOR); 5604 DEFINE_INTEGER(GLU_NURBS_TEXTURE_COORD); 5605 DEFINE_INTEGER(GLU_NURBS_END); 5606 DEFINE_INTEGER(GLU_NURBS_BEGIN_DATA); 5607 DEFINE_INTEGER(GLU_NURBS_VERTEX_DATA); 5608 DEFINE_INTEGER(GLU_NURBS_NORMAL_DATA); 5609 DEFINE_INTEGER(GLU_NURBS_COLOR_DATA); 5610 DEFINE_INTEGER(GLU_NURBS_TEXTURE_COORD_DATA); 5611 DEFINE_INTEGER(GLU_NURBS_END_DATA); 5612 DEFINE_INTEGER(GLU_NURBS_ERROR1); 5613 DEFINE_INTEGER(GLU_NURBS_ERROR2); 5614 DEFINE_INTEGER(GLU_NURBS_ERROR3); 5615 DEFINE_INTEGER(GLU_NURBS_ERROR4); 5616 DEFINE_INTEGER(GLU_NURBS_ERROR5); 5617 DEFINE_INTEGER(GLU_NURBS_ERROR6); 5618 DEFINE_INTEGER(GLU_NURBS_ERROR7); 5619 DEFINE_INTEGER(GLU_NURBS_ERROR8); 5620 DEFINE_INTEGER(GLU_NURBS_ERROR9); 5621 DEFINE_INTEGER(GLU_NURBS_ERROR10); 5622 DEFINE_INTEGER(GLU_NURBS_ERROR11); 5623 DEFINE_INTEGER(GLU_NURBS_ERROR12); 5624 DEFINE_INTEGER(GLU_NURBS_ERROR13); 5625 DEFINE_INTEGER(GLU_NURBS_ERROR14); 5626 DEFINE_INTEGER(GLU_NURBS_ERROR15); 5627 DEFINE_INTEGER(GLU_NURBS_ERROR16); 5628 DEFINE_INTEGER(GLU_NURBS_ERROR17); 5629 DEFINE_INTEGER(GLU_NURBS_ERROR18); 5630 DEFINE_INTEGER(GLU_NURBS_ERROR19); 5631 DEFINE_INTEGER(GLU_NURBS_ERROR20); 5632 DEFINE_INTEGER(GLU_NURBS_ERROR21); 5633 DEFINE_INTEGER(GLU_NURBS_ERROR22); 5634 DEFINE_INTEGER(GLU_NURBS_ERROR23); 5635 DEFINE_INTEGER(GLU_NURBS_ERROR24); 5636 DEFINE_INTEGER(GLU_NURBS_ERROR25); 5637 DEFINE_INTEGER(GLU_NURBS_ERROR26); 5638 DEFINE_INTEGER(GLU_NURBS_ERROR27); 5639 DEFINE_INTEGER(GLU_NURBS_ERROR28); 5640 DEFINE_INTEGER(GLU_NURBS_ERROR29); 5641 DEFINE_INTEGER(GLU_NURBS_ERROR30); 5642 DEFINE_INTEGER(GLU_NURBS_ERROR31); 5643 DEFINE_INTEGER(GLU_NURBS_ERROR32); 5644 DEFINE_INTEGER(GLU_NURBS_ERROR33); 5645 DEFINE_INTEGER(GLU_NURBS_ERROR34); 5646 DEFINE_INTEGER(GLU_NURBS_ERROR35); 5647 DEFINE_INTEGER(GLU_NURBS_ERROR36); 5648 DEFINE_INTEGER(GLU_NURBS_ERROR37); 5649 DEFINE_INTEGER(GLU_AUTO_LOAD_MATRIX); 5650 DEFINE_INTEGER(GLU_CULLING); 5651 DEFINE_INTEGER(GLU_SAMPLING_TOLERANCE); 5652 DEFINE_INTEGER(GLU_DISPLAY_MODE); 5653 DEFINE_INTEGER(GLU_PARAMETRIC_TOLERANCE); 5654 DEFINE_INTEGER(GLU_SAMPLING_METHOD); 5655 DEFINE_INTEGER(GLU_U_STEP); 5656 DEFINE_INTEGER(GLU_V_STEP); 5657 DEFINE_INTEGER(GLU_NURBS_MODE); 5658 DEFINE_INTEGER(GLU_NURBS_TESSELLATOR); 5659 DEFINE_INTEGER(GLU_NURBS_RENDERER); 5660 DEFINE_INTEGER(GLU_OBJECT_PARAMETRIC_ERROR); 5661 DEFINE_INTEGER(GLU_OBJECT_PATH_LENGTH); 5662 DEFINE_INTEGER(GLU_PATH_LENGTH); 5663 DEFINE_INTEGER(GLU_PARAMETRIC_ERROR); 5664 DEFINE_INTEGER(GLU_DOMAIN_DISTANCE); 5665 DEFINE_INTEGER(GLU_MAP1_TRIM_2); 5666 DEFINE_INTEGER(GLU_MAP1_TRIM_3); 5667 DEFINE_INTEGER(GLU_POINT); 5668 DEFINE_INTEGER(GLU_LINE); 5669 DEFINE_INTEGER(GLU_FILL); 5670 DEFINE_INTEGER(GLU_SILHOUETTE); 5671 DEFINE_INTEGER(GLU_SMOOTH); 5672 DEFINE_INTEGER(GLU_FLAT); 5673 DEFINE_INTEGER(GLU_NONE); 5674 DEFINE_INTEGER(GLU_OUTSIDE); 5675 DEFINE_INTEGER(GLU_INSIDE); 5676 DEFINE_INTEGER(GLU_TESS_BEGIN); 5677 DEFINE_INTEGER(GLU_BEGIN); 5678 DEFINE_INTEGER(GLU_TESS_VERTEX); 5679 DEFINE_INTEGER(GLU_VERTEX); 5680 DEFINE_INTEGER(GLU_TESS_END); 5681 DEFINE_INTEGER(GLU_END); 5682 DEFINE_INTEGER(GLU_TESS_ERROR); 5683 DEFINE_INTEGER(GLU_TESS_EDGE_FLAG); 5684 DEFINE_INTEGER(GLU_EDGE_FLAG); 5685 DEFINE_INTEGER(GLU_TESS_COMBINE); 5686 DEFINE_INTEGER(GLU_TESS_BEGIN_DATA); 5687 DEFINE_INTEGER(GLU_TESS_VERTEX_DATA); 5688 DEFINE_INTEGER(GLU_TESS_END_DATA); 5689 DEFINE_INTEGER(GLU_TESS_ERROR_DATA); 5690 DEFINE_INTEGER(GLU_TESS_EDGE_FLAG_DATA); 5691 DEFINE_INTEGER(GLU_TESS_COMBINE_DATA); 5692 DEFINE_INTEGER(GLU_CW); 5693 DEFINE_INTEGER(GLU_CCW); 5694 DEFINE_INTEGER(GLU_INTERIOR); 5695 DEFINE_INTEGER(GLU_EXTERIOR); 5696 DEFINE_INTEGER(GLU_UNKNOWN); 5697 DEFINE_INTEGER(GLU_TESS_WINDING_RULE); 5698 DEFINE_INTEGER(GLU_TESS_BOUNDARY_ONLY); 5699 DEFINE_INTEGER(GLU_TESS_TOLERANCE); 5700 DEFINE_INTEGER(GLU_TESS_ERROR1); 5701 DEFINE_INTEGER(GLU_TESS_ERROR2); 5702 DEFINE_INTEGER(GLU_TESS_ERROR3); 5703 DEFINE_INTEGER(GLU_TESS_ERROR4); 5704 DEFINE_INTEGER(GLU_TESS_ERROR5); 5705 DEFINE_INTEGER(GLU_TESS_ERROR6); 5706 DEFINE_INTEGER(GLU_TESS_ERROR7); 5707 DEFINE_INTEGER(GLU_TESS_ERROR8); 5708 DEFINE_INTEGER(GLU_TESS_MISSING_BEGIN_POLYGON); 5709 DEFINE_INTEGER(GLU_TESS_MISSING_BEGIN_CONTOUR); 5710 DEFINE_INTEGER(GLU_TESS_MISSING_END_POLYGON); 5711 DEFINE_INTEGER(GLU_TESS_MISSING_END_CONTOUR); 5712 DEFINE_INTEGER(GLU_TESS_COORD_TOO_LARGE); 5713 DEFINE_INTEGER(GLU_TESS_NEED_COMBINE_CALLBACK); 5714 DEFINE_INTEGER(GLU_TESS_WINDING_ODD); 5715 DEFINE_INTEGER(GLU_TESS_WINDING_NONZERO); 5716 DEFINE_INTEGER(GLU_TESS_WINDING_POSITIVE); 5717 DEFINE_INTEGER(GLU_TESS_WINDING_NEGATIVE); 5718 DEFINE_INTEGER(GLU_TESS_WINDING_ABS_GEQ_TWO); 5719 #endif 5720 } 5721 5722 /* -------------------------------- initialization -------------------------------- */ 5723 5724 static bool gl_already_inited = false; 5725 5726 #if HAVE_SCHEME 5727 void Init_libgl(s7_scheme *sc); 5728 void Init_libgl(s7_scheme *sc) 5729 #else 5730 void Init_libgl(void); 5731 void Init_libgl(void) 5732 #endif 5733 { 5734 if (!gl_already_inited) 5735 { 5736 define_integers(); 5737 define_functions(); 5738 Xen_provide_feature("gl"); 5739 Xen_define("gl-version", C_string_to_Xen_string("08-Mar-19")); 5740 gl_already_inited = true; 5741 } 5742 } 5743 #else 5744 void Init_libgl(void); 5745 void Init_libgl(void) 5746 { 5747 } 5748 #endif 5749