/* gl.c: Guile and Ruby bindings for GL, GLU
* generated automatically from makegl.scm and gldata.scm
* needs xen.h
*
* reference args are ignored if passed, resultant values are returned in a list.
* the various "v" forms are omitted for now -- are they needed in this context?
* 'gl is added to *features*
*
* HISTORY:
* 13-Jun-05: merged gl-ruby.c into gl.c.
* --------
* 10-Mar: Gl_Version.
* 1-Feb-03: glGet* funcs now try to handle multiple return values correctly.
* --------
* 18-Nov: added more GtkGlext bindings.
* 1-Aug: removed all 'EXT' junk.
* 24-July: changed Guile prefix (R5RS reserves vertical-bar).
* 18-June: GL 1.1 stubs.
* 4-June: GtkGLext support.
* 20-May-02: initial version.
*/
#include <config.h>
#if HAVE_EXTENSION_LANGUAGE
#if USE_GTK
#include <gtk/gtkgl.h>
#endif
#include <GL/gl.h>
#include <GL/glu.h>
#if USE_MOTIF
#include <GL/glx.h>
#endif
#include <string.h>
#if USE_SND
/* USE_SND causes xm to use Snd's error handlers which are much smarter than xen's fallback versions */
#include "snd.h"
#else
#include "xen.h"
#endif
#ifndef CALLOC
#define CALLOC(a, b) calloc((size_t)(a), (size_t)(b))
#define FREE(a) free(a)
#endif
#ifndef unsigned_long
/* for FreeBSD (thanks to Michael Scholz) (can't use ulong here due to collisions elsewhere) */
typedef unsigned long unsigned_long;
#endif
/* prefix for all names */
#if HAVE_SCHEME
#define XL_PRE ""
#define XL_POST ""
#endif
#if HAVE_RUBY
/* for Ruby, XG PRE needs to be uppercase */
#define XL_PRE "R"
#define XL_POST ""
#endif
#define WRAP_FOR_XEN(Name, Value) XEN_LIST_2(C_STRING_TO_XEN_SYMBOL(Name), C_TO_XEN_ULONG((unsigned long)Value))
#define WRAP_P(Name, Value) (XEN_LIST_P(Value) && \
(XEN_LIST_LENGTH(Value) >= 2) && \
(XEN_SYMBOL_P(XEN_CAR(Value))) && \
(strcmp(Name, XEN_SYMBOL_TO_C_STRING(XEN_CAR(Value))) == 0))
#define XL_TYPE(Name, XType) \
static XEN C_TO_XEN_ ## Name (XType val) {return(WRAP_FOR_XEN(#Name, val));} \
static XType XEN_TO_C_ ## Name (XEN val) {return((XType)XEN_TO_C_ULONG(XEN_CADR(val)));} \
static int XEN_ ## Name ## _P(XEN val) {return(WRAP_P(#Name, val));}
#define XL_TYPE_1(Name, XType) \
static XType XEN_TO_C_ ## Name (XEN val) {return((XType)XEN_TO_C_ULONG(XEN_CADR(val)));} \
static int XEN_ ## Name ## _P(XEN val) {return(WRAP_P(#Name, val));}
#define XL_TYPE_PTR(Name, XType) \
static XEN C_TO_XEN_ ## Name (XType val) {if (val) return(WRAP_FOR_XEN(#Name, val)); return(XEN_FALSE);} \
static XType XEN_TO_C_ ## Name (XEN val) {if (XEN_FALSE_P(val)) return(NULL); return((XType)XEN_TO_C_ULONG(XEN_CADR(val)));} \
static int XEN_ ## Name ## _P(XEN val) {return(WRAP_P(#Name, val));} /* if NULL ok, should be explicit */
#define XL_TYPE_PTR_1(Name, XType) \
static XType XEN_TO_C_ ## Name (XEN val) {if (XEN_FALSE_P(val)) return(NULL); return((XType)XEN_TO_C_ULONG(XEN_CADR(val)));} \
static int XEN_ ## Name ## _P(XEN val) {return(WRAP_P(#Name, val));} /* if NULL ok, should be explicit */
#define XL_TYPE_PTR_2(Name, XType) \
static XEN C_TO_XEN_ ## Name (XType val) {if (val) return(WRAP_FOR_XEN(#Name, val)); return(XEN_FALSE);}
/* ---------------------------------------- types ---------------------------------------- */
#if USE_MOTIF
XL_TYPE(XVisualInfo, XVisualInfo*)
XL_TYPE_1(Display, Display*)
#define C_TO_XEN_int(Arg) C_TO_XEN_INT(Arg)
#define XEN_TO_C_int(Arg) (int)(XEN_TO_C_INT(Arg))
#define XEN_int_P(Arg) XEN_INTEGER_P(Arg)
XL_TYPE_PTR_1(int_, int*)
XL_TYPE(GLXContext, GLXContext)
#define XEN_TO_C_unsigned_long(Arg) (unsigned_long)(XEN_TO_C_ULONG(Arg))
#define XEN_unsigned_long_P(Arg) XEN_ULONG_P(Arg)
#define C_TO_XEN_Bool(Arg) C_TO_XEN_BOOLEAN(Arg)
#define XEN_TO_C_Bool(Arg) (Bool)(XEN_TO_C_BOOLEAN(Arg))
#define XEN_Bool_P(Arg) XEN_BOOLEAN_P(Arg)
XL_TYPE(GLXPixmap, GLXPixmap)
XL_TYPE_1(Pixmap, Pixmap)
XL_TYPE(Window, Window)
XL_TYPE_1(Font, Font)
#define C_TO_XEN_char_(Arg) C_TO_XEN_STRING(Arg)
#define XEN_TO_C_char_(Arg) (char*)(XEN_TO_C_STRING(Arg))
#define XEN_char__P(Arg) XEN_STRING_P(Arg)
#endif
#if USE_GTK
#define C_TO_XEN_gboolean(Arg) C_TO_XEN_BOOLEAN(Arg)
#define XEN_TO_C_gboolean(Arg) (gboolean)(XEN_TO_C_BOOLEAN(Arg))
#define XEN_gboolean_P(Arg) XEN_BOOLEAN_P(Arg)
XL_TYPE_PTR_1(int_, int*)
#define C_TO_XEN_char_(Arg) C_TO_XEN_STRING(Arg)
#define XEN_TO_C_char_(Arg) (char*)(XEN_TO_C_STRING(Arg))
#define XEN_char__P(Arg) XEN_STRING_P(Arg)
XL_TYPE_PTR(GdkGLConfig_, GdkGLConfig*)
XL_TYPE_1(GdkGLConfigMode, GdkGLConfigMode)
#define C_TO_XEN_int(Arg) C_TO_XEN_INT(Arg)
#define XEN_TO_C_int(Arg) (int)(XEN_TO_C_INT(Arg))
#define XEN_int_P(Arg) XEN_INTEGER_P(Arg)
XL_TYPE_PTR_2(GdkColormap_, GdkColormap*)
XL_TYPE_PTR_2(GdkVisual_, GdkVisual*)
#define C_TO_XEN_gint(Arg) C_TO_XEN_INT(Arg)
#define XEN_TO_C_gint(Arg) (gint)(XEN_TO_C_INT(Arg))
#define XEN_gint_P(Arg) XEN_INTEGER_P(Arg)
XL_TYPE_PTR(GdkGLDrawable_, GdkGLDrawable*)
XL_TYPE_PTR(GdkGLContext_, GdkGLContext*)
XL_TYPE_PTR(GdkGLPixmap_, GdkGLPixmap*)
XL_TYPE_PTR(GdkPixmap_, GdkPixmap*)
XL_TYPE_PTR(GdkGLWindow_, GdkGLWindow*)
XL_TYPE_PTR(GdkWindow_, GdkWindow*)
XL_TYPE_PTR_2(PangoFont_, PangoFont*)
XL_TYPE_PTR_1(PangoFontDescription_, PangoFontDescription*)
XL_TYPE_PTR_1(GtkWidget_, GtkWidget*)
#endif
#define C_TO_XEN_GLfloat(Arg) C_TO_XEN_DOUBLE(Arg)
#define XEN_TO_C_GLfloat(Arg) (GLfloat)(XEN_TO_C_DOUBLE(Arg))
#define XEN_GLfloat_P(Arg) XEN_NUMBER_P(Arg)
#define XEN_TO_C_GLclampf(Arg) (GLclampf)(XEN_TO_C_DOUBLE(Arg))
#define XEN_GLclampf_P(Arg) XEN_NUMBER_P(Arg)
#define XEN_TO_C_GLbitfield(Arg) (GLbitfield)(XEN_TO_C_ULONG(Arg))
#define XEN_GLbitfield_P(Arg) XEN_ULONG_P(Arg)
#define C_TO_XEN_GLuint(Arg) C_TO_XEN_ULONG(Arg)
#define XEN_TO_C_GLuint(Arg) (GLuint)(XEN_TO_C_ULONG(Arg))
#define XEN_GLuint_P(Arg) XEN_ULONG_P(Arg)
#define C_TO_XEN_GLboolean(Arg) C_TO_XEN_BOOLEAN(Arg)
#define XEN_TO_C_GLboolean(Arg) (GLboolean)(XEN_TO_C_BOOLEAN(Arg))
#define XEN_GLboolean_P(Arg) XEN_BOOLEAN_P(Arg)
#define C_TO_XEN_GLenum(Arg) C_TO_XEN_INT(Arg)
#define XEN_TO_C_GLenum(Arg) (GLenum)(XEN_TO_C_INT(Arg))
#define XEN_GLenum_P(Arg) XEN_INTEGER_P(Arg)
#define C_TO_XEN_GLint(Arg) C_TO_XEN_INT(Arg)
#define XEN_TO_C_GLint(Arg) (GLint)(XEN_TO_C_INT(Arg))
#define XEN_GLint_P(Arg) XEN_INTEGER_P(Arg)
#define C_TO_XEN_GLushort(Arg) C_TO_XEN_INT(Arg)
#define XEN_TO_C_GLushort(Arg) (GLushort)(XEN_TO_C_INT(Arg))
#define XEN_GLushort_P(Arg) XEN_INTEGER_P(Arg)
XL_TYPE_PTR_1(GLubyte_, GLubyte*)
#define XEN_TO_C_GLsizei(Arg) (GLsizei)(XEN_TO_C_INT(Arg))
#define XEN_GLsizei_P(Arg) XEN_INTEGER_P(Arg)
XL_TYPE_PTR_1(GLdouble_, GLdouble*)
#define C_TO_XEN_GLdouble(Arg) C_TO_XEN_DOUBLE(Arg)
#define XEN_TO_C_GLdouble(Arg) (GLdouble)(XEN_TO_C_DOUBLE(Arg))
#define XEN_GLdouble_P(Arg) XEN_NUMBER_P(Arg)
#define C_TO_XEN_constchar_(Arg) C_TO_XEN_STRING((char *)(Arg))
#define XEN_TO_C_GLclampd(Arg) (GLclampd)(XEN_TO_C_DOUBLE(Arg))
#define XEN_GLclampd_P(Arg) XEN_NUMBER_P(Arg)
XL_TYPE_PTR_1(GLfloat_, GLfloat*)
XL_TYPE_PTR_1(GLvoid_, GLvoid*)
#define XEN_TO_C_GLshort(Arg) (GLshort)(XEN_TO_C_INT(Arg))
#define XEN_GLshort_P(Arg) XEN_INTEGER_P(Arg)
#define XEN_TO_C_GLbyte(Arg) (GLbyte)(XEN_TO_C_INT(Arg))
#define XEN_GLbyte_P(Arg) XEN_INTEGER_P(Arg)
#define XEN_TO_C_GLubyte(Arg) (GLubyte)(XEN_TO_C_INT(Arg))
#define XEN_GLubyte_P(Arg) XEN_INTEGER_P(Arg)
XL_TYPE_PTR(void_, void*)
XL_TYPE_PTR_1(GLuint_, GLuint*)
XL_TYPE_PTR_1(GLboolean_, GLboolean*)
#ifdef GLU_VERSION_1_2
XL_TYPE_PTR(GLUtesselator_, GLUtesselator*)
#endif
XL_TYPE_PTR_1(GLint_, GLint*)
/* ---------------------------------------- state readback confusion ---------------------------------------- */
static int how_many_vals(GLenum gl)
{
switch (gl)
{
case GL_CURRENT_COLOR:
case GL_CURRENT_TEXTURE_COORDS:
case GL_CURRENT_RASTER_POSITION:
case GL_CURRENT_RASTER_COLOR:
case GL_CURRENT_RASTER_TEXTURE_COORDS:
case GL_VIEWPORT:
case GL_FOG_COLOR:
case GL_AMBIENT:
case GL_DIFFUSE:
case GL_SPECULAR:
case GL_EMISSION:
case GL_LIGHT_MODEL_AMBIENT:
case GL_SCISSOR_BOX:
case GL_COLOR_WRITEMASK:
case GL_COLOR_CLEAR_VALUE:
return(4);
break;
case GL_MODELVIEW_MATRIX:
case GL_PROJECTION_MATRIX:
case GL_TEXTURE_MATRIX:
return(16);
break;
case GL_CURRENT_NORMAL:
case GL_SPOT_DIRECTION:
return(3);
break;
case GL_DEPTH_RANGE:
case GL_LINE_WIDTH_RANGE:
return(2);
break;
default: return(1); break; /* try to squelch c++ babbling */
}
return(1);
}
/* ---------------------------------------- functions ---------------------------------------- */
#if USE_MOTIF
static XEN gxg_glXChooseVisual(XEN dpy, XEN screen, XEN attribList)
{
#define H_glXChooseVisual "XVisualInfo* glXChooseVisual(Display* dpy, int screen, int* attribList)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXChooseVisual", "Display*");
XEN_ASSERT_TYPE(XEN_int_P(screen), screen, 2, "glXChooseVisual", "int");
XEN_ASSERT_TYPE(XEN_int__P(attribList), attribList, 3, "glXChooseVisual", "int*");
return(C_TO_XEN_XVisualInfo(glXChooseVisual(XEN_TO_C_Display(dpy), XEN_TO_C_int(screen), XEN_TO_C_int_(attribList))));
}
static XEN gxg_glXCopyContext(XEN dpy, XEN src, XEN dst, XEN mask)
{
#define H_glXCopyContext "void glXCopyContext(Display* dpy, GLXContext src, GLXContext dst, unsigned_long mask)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXCopyContext", "Display*");
XEN_ASSERT_TYPE(XEN_GLXContext_P(src), src, 2, "glXCopyContext", "GLXContext");
XEN_ASSERT_TYPE(XEN_GLXContext_P(dst), dst, 3, "glXCopyContext", "GLXContext");
XEN_ASSERT_TYPE(XEN_unsigned_long_P(mask), mask, 4, "glXCopyContext", "unsigned_long");
glXCopyContext(XEN_TO_C_Display(dpy), XEN_TO_C_GLXContext(src), XEN_TO_C_GLXContext(dst), XEN_TO_C_unsigned_long(mask));
return(XEN_FALSE);
}
static XEN gxg_glXCreateContext(XEN dpy, XEN vis, XEN shareList, XEN direct)
{
#define H_glXCreateContext "GLXContext glXCreateContext(Display* dpy, XVisualInfo* vis, GLXContext shareList, \
Bool direct)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXCreateContext", "Display*");
XEN_ASSERT_TYPE(XEN_XVisualInfo_P(vis), vis, 2, "glXCreateContext", "XVisualInfo*");
XEN_ASSERT_TYPE(XEN_GLXContext_P(shareList), shareList, 3, "glXCreateContext", "GLXContext");
XEN_ASSERT_TYPE(XEN_Bool_P(direct), direct, 4, "glXCreateContext", "Bool");
return(C_TO_XEN_GLXContext(glXCreateContext(XEN_TO_C_Display(dpy), XEN_TO_C_XVisualInfo(vis), XEN_TO_C_GLXContext(shareList),
XEN_TO_C_Bool(direct))));
}
static XEN gxg_glXCreateGLXPixmap(XEN dpy, XEN vis, XEN pixmap)
{
#define H_glXCreateGLXPixmap "GLXPixmap glXCreateGLXPixmap(Display* dpy, XVisualInfo* vis, Pixmap pixmap)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXCreateGLXPixmap", "Display*");
XEN_ASSERT_TYPE(XEN_XVisualInfo_P(vis), vis, 2, "glXCreateGLXPixmap", "XVisualInfo*");
XEN_ASSERT_TYPE(XEN_Pixmap_P(pixmap), pixmap, 3, "glXCreateGLXPixmap", "Pixmap");
return(C_TO_XEN_GLXPixmap(glXCreateGLXPixmap(XEN_TO_C_Display(dpy), XEN_TO_C_XVisualInfo(vis), XEN_TO_C_Pixmap(pixmap))));
}
static XEN gxg_glXDestroyContext(XEN dpy, XEN ctx)
{
#define H_glXDestroyContext "void glXDestroyContext(Display* dpy, GLXContext ctx)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXDestroyContext", "Display*");
XEN_ASSERT_TYPE(XEN_GLXContext_P(ctx), ctx, 2, "glXDestroyContext", "GLXContext");
glXDestroyContext(XEN_TO_C_Display(dpy), XEN_TO_C_GLXContext(ctx));
return(XEN_FALSE);
}
static XEN gxg_glXDestroyGLXPixmap(XEN dpy, XEN pix)
{
#define H_glXDestroyGLXPixmap "void glXDestroyGLXPixmap(Display* dpy, GLXPixmap pix)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXDestroyGLXPixmap", "Display*");
XEN_ASSERT_TYPE(XEN_GLXPixmap_P(pix), pix, 2, "glXDestroyGLXPixmap", "GLXPixmap");
glXDestroyGLXPixmap(XEN_TO_C_Display(dpy), XEN_TO_C_GLXPixmap(pix));
return(XEN_FALSE);
}
static XEN gxg_glXGetConfig(XEN dpy, XEN vis, XEN attrib, XEN value)
{
#define H_glXGetConfig "int glXGetConfig(Display* dpy, XVisualInfo* vis, int attrib, int* [value])"
int ref_value[1];
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXGetConfig", "Display*");
XEN_ASSERT_TYPE(XEN_XVisualInfo_P(vis), vis, 2, "glXGetConfig", "XVisualInfo*");
XEN_ASSERT_TYPE(XEN_int_P(attrib), attrib, 3, "glXGetConfig", "int");
{
XEN result = XEN_FALSE;
result = C_TO_XEN_int(glXGetConfig(XEN_TO_C_Display(dpy), XEN_TO_C_XVisualInfo(vis), XEN_TO_C_int(attrib), ref_value));
return(XEN_LIST_2(result, C_TO_XEN_int(ref_value[0])));
}
}
static XEN gxg_glXGetCurrentContext(void)
{
#define H_glXGetCurrentContext "GLXContext glXGetCurrentContext( void)"
return(C_TO_XEN_GLXContext(glXGetCurrentContext()));
}
static XEN gxg_glXGetCurrentDrawable(void)
{
#define H_glXGetCurrentDrawable "Window glXGetCurrentDrawable( void)"
return(C_TO_XEN_Window(glXGetCurrentDrawable()));
}
static XEN gxg_glXIsDirect(XEN dpy, XEN ctx)
{
#define H_glXIsDirect "Bool glXIsDirect(Display* dpy, GLXContext ctx)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXIsDirect", "Display*");
XEN_ASSERT_TYPE(XEN_GLXContext_P(ctx), ctx, 2, "glXIsDirect", "GLXContext");
return(C_TO_XEN_Bool(glXIsDirect(XEN_TO_C_Display(dpy), XEN_TO_C_GLXContext(ctx))));
}
static XEN gxg_glXMakeCurrent(XEN dpy, XEN drawable, XEN ctx)
{
#define H_glXMakeCurrent "Bool glXMakeCurrent(Display* dpy, Window drawable, GLXContext ctx)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXMakeCurrent", "Display*");
XEN_ASSERT_TYPE(XEN_Window_P(drawable), drawable, 2, "glXMakeCurrent", "Window");
XEN_ASSERT_TYPE(XEN_GLXContext_P(ctx), ctx, 3, "glXMakeCurrent", "GLXContext");
return(C_TO_XEN_Bool(glXMakeCurrent(XEN_TO_C_Display(dpy), XEN_TO_C_Window(drawable), XEN_TO_C_GLXContext(ctx))));
}
static XEN gxg_glXQueryExtension(XEN dpy, XEN errorBase, XEN eventBase)
{
#define H_glXQueryExtension "Bool glXQueryExtension(Display* dpy, int* [errorBase], int* [eventBase])"
int ref_errorBase[1];
int ref_eventBase[1];
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXQueryExtension", "Display*");
{
XEN result = XEN_FALSE;
result = C_TO_XEN_Bool(glXQueryExtension(XEN_TO_C_Display(dpy), ref_errorBase, ref_eventBase));
return(XEN_LIST_3(result, C_TO_XEN_int(ref_errorBase[0]), C_TO_XEN_int(ref_eventBase[0])));
}
}
static XEN gxg_glXQueryVersion(XEN dpy, XEN major, XEN minor)
{
#define H_glXQueryVersion "Bool glXQueryVersion(Display* dpy, int* [major], int* [minor])"
int ref_major[1];
int ref_minor[1];
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXQueryVersion", "Display*");
{
XEN result = XEN_FALSE;
result = C_TO_XEN_Bool(glXQueryVersion(XEN_TO_C_Display(dpy), ref_major, ref_minor));
return(XEN_LIST_3(result, C_TO_XEN_int(ref_major[0]), C_TO_XEN_int(ref_minor[0])));
}
}
static XEN gxg_glXSwapBuffers(XEN dpy, XEN drawable)
{
#define H_glXSwapBuffers "void glXSwapBuffers(Display* dpy, Window drawable)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXSwapBuffers", "Display*");
XEN_ASSERT_TYPE(XEN_Window_P(drawable), drawable, 2, "glXSwapBuffers", "Window");
glXSwapBuffers(XEN_TO_C_Display(dpy), XEN_TO_C_Window(drawable));
return(XEN_FALSE);
}
static XEN gxg_glXUseXFont(XEN font, XEN first, XEN count, XEN listBase)
{
#define H_glXUseXFont "void glXUseXFont(Font font, int first, int count, int listBase)"
XEN_ASSERT_TYPE(XEN_Font_P(font), font, 1, "glXUseXFont", "Font");
XEN_ASSERT_TYPE(XEN_int_P(first), first, 2, "glXUseXFont", "int");
XEN_ASSERT_TYPE(XEN_int_P(count), count, 3, "glXUseXFont", "int");
XEN_ASSERT_TYPE(XEN_int_P(listBase), listBase, 4, "glXUseXFont", "int");
glXUseXFont(XEN_TO_C_Font(font), XEN_TO_C_int(first), XEN_TO_C_int(count), XEN_TO_C_int(listBase));
return(XEN_FALSE);
}
static XEN gxg_glXWaitGL(void)
{
#define H_glXWaitGL "void glXWaitGL( void)"
glXWaitGL();
return(XEN_FALSE);
}
static XEN gxg_glXWaitX(void)
{
#define H_glXWaitX "void glXWaitX( void)"
glXWaitX();
return(XEN_FALSE);
}
static XEN gxg_glXGetClientString(XEN dpy, XEN name)
{
#define H_glXGetClientString "char* glXGetClientString(Display* dpy, int name)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXGetClientString", "Display*");
XEN_ASSERT_TYPE(XEN_int_P(name), name, 2, "glXGetClientString", "int");
return(C_TO_XEN_char_(glXGetClientString(XEN_TO_C_Display(dpy), XEN_TO_C_int(name))));
}
static XEN gxg_glXQueryServerString(XEN dpy, XEN screen, XEN name)
{
#define H_glXQueryServerString "char* glXQueryServerString(Display* dpy, int screen, int name)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXQueryServerString", "Display*");
XEN_ASSERT_TYPE(XEN_int_P(screen), screen, 2, "glXQueryServerString", "int");
XEN_ASSERT_TYPE(XEN_int_P(name), name, 3, "glXQueryServerString", "int");
return(C_TO_XEN_char_(glXQueryServerString(XEN_TO_C_Display(dpy), XEN_TO_C_int(screen), XEN_TO_C_int(name))));
}
static XEN gxg_glXQueryExtensionsString(XEN dpy, XEN screen)
{
#define H_glXQueryExtensionsString "char* glXQueryExtensionsString(Display* dpy, int screen)"
XEN_ASSERT_TYPE(XEN_Display_P(dpy), dpy, 1, "glXQueryExtensionsString", "Display*");
XEN_ASSERT_TYPE(XEN_int_P(screen), screen, 2, "glXQueryExtensionsString", "int");
return(C_TO_XEN_char_(glXQueryExtensionsString(XEN_TO_C_Display(dpy), XEN_TO_C_int(screen))));
}
#endif
#if USE_GTK
static XEN gxg_gdk_gl_query_extension(void)
{
#define H_gdk_gl_query_extension "gboolean gdk_gl_query_extension( void)"
return(C_TO_XEN_gboolean(gdk_gl_query_extension()));
}
static XEN gxg_gdk_gl_query_version(XEN major, XEN minor)
{
#define H_gdk_gl_query_version "gboolean gdk_gl_query_version(int* major, int* minor)"
XEN_ASSERT_TYPE(XEN_int__P(major), major, 1, "gdk_gl_query_version", "int*");
XEN_ASSERT_TYPE(XEN_int__P(minor), minor, 2, "gdk_gl_query_version", "int*");
return(C_TO_XEN_gboolean(gdk_gl_query_version(XEN_TO_C_int_(major), XEN_TO_C_int_(minor))));
}
static XEN gxg_gdk_gl_query_gl_extension(XEN extension)
{
#define H_gdk_gl_query_gl_extension "gboolean gdk_gl_query_gl_extension(char* extension)"
XEN_ASSERT_TYPE(XEN_char__P(extension), extension, 1, "gdk_gl_query_gl_extension", "char*");
return(C_TO_XEN_gboolean(gdk_gl_query_gl_extension(XEN_TO_C_char_(extension))));
}
static XEN gxg_gdk_gl_config_new(XEN attrib_list)
{
#define H_gdk_gl_config_new "GdkGLConfig* gdk_gl_config_new(int* attrib_list)"
XEN_ASSERT_TYPE(XEN_int__P(attrib_list), attrib_list, 1, "gdk_gl_config_new", "int*");
return(C_TO_XEN_GdkGLConfig_(gdk_gl_config_new(XEN_TO_C_int_(attrib_list))));
}
static XEN gxg_gdk_gl_config_new_by_mode(XEN mode)
{
#define H_gdk_gl_config_new_by_mode "GdkGLConfig* gdk_gl_config_new_by_mode(GdkGLConfigMode mode)"
XEN_ASSERT_TYPE(XEN_GdkGLConfigMode_P(mode), mode, 1, "gdk_gl_config_new_by_mode", "GdkGLConfigMode");
return(C_TO_XEN_GdkGLConfig_(gdk_gl_config_new_by_mode(XEN_TO_C_GdkGLConfigMode(mode))));
}
static XEN gxg_gdk_gl_config_get_attrib(XEN glconfig, XEN attribute, XEN value)
{
#define H_gdk_gl_config_get_attrib "gboolean gdk_gl_config_get_attrib(GdkGLConfig* glconfig, int attribute, \
int* [value])"
int ref_value[1];
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_get_attrib", "GdkGLConfig*");
XEN_ASSERT_TYPE(XEN_int_P(attribute), attribute, 2, "gdk_gl_config_get_attrib", "int");
{
XEN result = XEN_FALSE;
result = C_TO_XEN_gboolean(gdk_gl_config_get_attrib(XEN_TO_C_GdkGLConfig_(glconfig), XEN_TO_C_int(attribute), ref_value));
return(XEN_LIST_2(result, C_TO_XEN_int(ref_value[0])));
}
}
static XEN gxg_gdk_gl_config_get_colormap(XEN glconfig)
{
#define H_gdk_gl_config_get_colormap "GdkColormap* gdk_gl_config_get_colormap(GdkGLConfig* glconfig)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_get_colormap", "GdkGLConfig*");
return(C_TO_XEN_GdkColormap_(gdk_gl_config_get_colormap(XEN_TO_C_GdkGLConfig_(glconfig))));
}
static XEN gxg_gdk_gl_config_get_visual(XEN glconfig)
{
#define H_gdk_gl_config_get_visual "GdkVisual* gdk_gl_config_get_visual(GdkGLConfig* glconfig)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_get_visual", "GdkGLConfig*");
return(C_TO_XEN_GdkVisual_(gdk_gl_config_get_visual(XEN_TO_C_GdkGLConfig_(glconfig))));
}
static XEN gxg_gdk_gl_config_get_depth(XEN glconfig)
{
#define H_gdk_gl_config_get_depth "gint gdk_gl_config_get_depth(GdkGLConfig* glconfig)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_get_depth", "GdkGLConfig*");
return(C_TO_XEN_gint(gdk_gl_config_get_depth(XEN_TO_C_GdkGLConfig_(glconfig))));
}
static XEN gxg_gdk_gl_config_is_rgba(XEN glconfig)
{
#define H_gdk_gl_config_is_rgba "gboolean gdk_gl_config_is_rgba(GdkGLConfig* glconfig)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_is_rgba", "GdkGLConfig*");
return(C_TO_XEN_gboolean(gdk_gl_config_is_rgba(XEN_TO_C_GdkGLConfig_(glconfig))));
}
static XEN gxg_gdk_gl_config_is_double_buffered(XEN glconfig)
{
#define H_gdk_gl_config_is_double_buffered "gboolean gdk_gl_config_is_double_buffered(GdkGLConfig* glconfig)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_is_double_buffered", "GdkGLConfig*");
return(C_TO_XEN_gboolean(gdk_gl_config_is_double_buffered(XEN_TO_C_GdkGLConfig_(glconfig))));
}
static XEN gxg_gdk_gl_config_is_stereo(XEN glconfig)
{
#define H_gdk_gl_config_is_stereo "gboolean gdk_gl_config_is_stereo(GdkGLConfig* glconfig)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_is_stereo", "GdkGLConfig*");
return(C_TO_XEN_gboolean(gdk_gl_config_is_stereo(XEN_TO_C_GdkGLConfig_(glconfig))));
}
static XEN gxg_gdk_gl_config_has_alpha(XEN glconfig)
{
#define H_gdk_gl_config_has_alpha "gboolean gdk_gl_config_has_alpha(GdkGLConfig* glconfig)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_has_alpha", "GdkGLConfig*");
return(C_TO_XEN_gboolean(gdk_gl_config_has_alpha(XEN_TO_C_GdkGLConfig_(glconfig))));
}
static XEN gxg_gdk_gl_config_has_depth_buffer(XEN glconfig)
{
#define H_gdk_gl_config_has_depth_buffer "gboolean gdk_gl_config_has_depth_buffer(GdkGLConfig* glconfig)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_has_depth_buffer", "GdkGLConfig*");
return(C_TO_XEN_gboolean(gdk_gl_config_has_depth_buffer(XEN_TO_C_GdkGLConfig_(glconfig))));
}
static XEN gxg_gdk_gl_config_has_stencil_buffer(XEN glconfig)
{
#define H_gdk_gl_config_has_stencil_buffer "gboolean gdk_gl_config_has_stencil_buffer(GdkGLConfig* glconfig)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_has_stencil_buffer", "GdkGLConfig*");
return(C_TO_XEN_gboolean(gdk_gl_config_has_stencil_buffer(XEN_TO_C_GdkGLConfig_(glconfig))));
}
static XEN gxg_gdk_gl_config_has_accum_buffer(XEN glconfig)
{
#define H_gdk_gl_config_has_accum_buffer "gboolean gdk_gl_config_has_accum_buffer(GdkGLConfig* glconfig)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_config_has_accum_buffer", "GdkGLConfig*");
return(C_TO_XEN_gboolean(gdk_gl_config_has_accum_buffer(XEN_TO_C_GdkGLConfig_(glconfig))));
}
static XEN gxg_gdk_gl_context_get_gl_drawable(XEN glcontext)
{
#define H_gdk_gl_context_get_gl_drawable "GdkGLDrawable* gdk_gl_context_get_gl_drawable(GdkGLContext* glcontext)"
XEN_ASSERT_TYPE(XEN_GdkGLContext__P(glcontext), glcontext, 1, "gdk_gl_context_get_gl_drawable", "GdkGLContext*");
return(C_TO_XEN_GdkGLDrawable_(gdk_gl_context_get_gl_drawable(XEN_TO_C_GdkGLContext_(glcontext))));
}
static XEN gxg_gdk_gl_context_get_gl_config(XEN glcontext)
{
#define H_gdk_gl_context_get_gl_config "GdkGLConfig* gdk_gl_context_get_gl_config(GdkGLContext* glcontext)"
XEN_ASSERT_TYPE(XEN_GdkGLContext__P(glcontext), glcontext, 1, "gdk_gl_context_get_gl_config", "GdkGLContext*");
return(C_TO_XEN_GdkGLConfig_(gdk_gl_context_get_gl_config(XEN_TO_C_GdkGLContext_(glcontext))));
}
static XEN gxg_gdk_gl_context_get_share_list(XEN glcontext)
{
#define H_gdk_gl_context_get_share_list "GdkGLContext* gdk_gl_context_get_share_list(GdkGLContext* glcontext)"
XEN_ASSERT_TYPE(XEN_GdkGLContext__P(glcontext), glcontext, 1, "gdk_gl_context_get_share_list", "GdkGLContext*");
return(C_TO_XEN_GdkGLContext_(gdk_gl_context_get_share_list(XEN_TO_C_GdkGLContext_(glcontext))));
}
static XEN gxg_gdk_gl_context_is_direct(XEN glcontext)
{
#define H_gdk_gl_context_is_direct "gboolean gdk_gl_context_is_direct(GdkGLContext* glcontext)"
XEN_ASSERT_TYPE(XEN_GdkGLContext__P(glcontext), glcontext, 1, "gdk_gl_context_is_direct", "GdkGLContext*");
return(C_TO_XEN_gboolean(gdk_gl_context_is_direct(XEN_TO_C_GdkGLContext_(glcontext))));
}
static XEN gxg_gdk_gl_context_get_render_type(XEN glcontext)
{
#define H_gdk_gl_context_get_render_type "int gdk_gl_context_get_render_type(GdkGLContext* glcontext)"
XEN_ASSERT_TYPE(XEN_GdkGLContext__P(glcontext), glcontext, 1, "gdk_gl_context_get_render_type", "GdkGLContext*");
return(C_TO_XEN_int(gdk_gl_context_get_render_type(XEN_TO_C_GdkGLContext_(glcontext))));
}
static XEN gxg_gdk_gl_drawable_make_current(XEN gldrawable, XEN glcontext)
{
#define H_gdk_gl_drawable_make_current "gboolean gdk_gl_drawable_make_current(GdkGLDrawable* gldrawable, \
GdkGLContext* glcontext)"
XEN_ASSERT_TYPE(XEN_GdkGLDrawable__P(gldrawable), gldrawable, 1, "gdk_gl_drawable_make_current", "GdkGLDrawable*");
XEN_ASSERT_TYPE(XEN_GdkGLContext__P(glcontext), glcontext, 2, "gdk_gl_drawable_make_current", "GdkGLContext*");
return(C_TO_XEN_gboolean(gdk_gl_drawable_make_current(XEN_TO_C_GdkGLDrawable_(gldrawable), XEN_TO_C_GdkGLContext_(glcontext))));
}
static XEN gxg_gdk_gl_drawable_is_double_buffered(XEN gldrawable)
{
#define H_gdk_gl_drawable_is_double_buffered "gboolean gdk_gl_drawable_is_double_buffered(GdkGLDrawable* gldrawable)"
XEN_ASSERT_TYPE(XEN_GdkGLDrawable__P(gldrawable), gldrawable, 1, "gdk_gl_drawable_is_double_buffered", "GdkGLDrawable*");
return(C_TO_XEN_gboolean(gdk_gl_drawable_is_double_buffered(XEN_TO_C_GdkGLDrawable_(gldrawable))));
}
static XEN gxg_gdk_gl_drawable_swap_buffers(XEN gldrawable)
{
#define H_gdk_gl_drawable_swap_buffers "void gdk_gl_drawable_swap_buffers(GdkGLDrawable* gldrawable)"
XEN_ASSERT_TYPE(XEN_GdkGLDrawable__P(gldrawable), gldrawable, 1, "gdk_gl_drawable_swap_buffers", "GdkGLDrawable*");
gdk_gl_drawable_swap_buffers(XEN_TO_C_GdkGLDrawable_(gldrawable));
return(XEN_FALSE);
}
static XEN gxg_gdk_gl_drawable_wait_gl(XEN gldrawable)
{
#define H_gdk_gl_drawable_wait_gl "void gdk_gl_drawable_wait_gl(GdkGLDrawable* gldrawable)"
XEN_ASSERT_TYPE(XEN_GdkGLDrawable__P(gldrawable), gldrawable, 1, "gdk_gl_drawable_wait_gl", "GdkGLDrawable*");
gdk_gl_drawable_wait_gl(XEN_TO_C_GdkGLDrawable_(gldrawable));
return(XEN_FALSE);
}
static XEN gxg_gdk_gl_drawable_wait_gdk(XEN gldrawable)
{
#define H_gdk_gl_drawable_wait_gdk "void gdk_gl_drawable_wait_gdk(GdkGLDrawable* gldrawable)"
XEN_ASSERT_TYPE(XEN_GdkGLDrawable__P(gldrawable), gldrawable, 1, "gdk_gl_drawable_wait_gdk", "GdkGLDrawable*");
gdk_gl_drawable_wait_gdk(XEN_TO_C_GdkGLDrawable_(gldrawable));
return(XEN_FALSE);
}
static XEN gxg_gdk_gl_drawable_get_gl_config(XEN gldrawable)
{
#define H_gdk_gl_drawable_get_gl_config "GdkGLConfig* gdk_gl_drawable_get_gl_config(GdkGLDrawable* gldrawable)"
XEN_ASSERT_TYPE(XEN_GdkGLDrawable__P(gldrawable), gldrawable, 1, "gdk_gl_drawable_get_gl_config", "GdkGLDrawable*");
return(C_TO_XEN_GdkGLConfig_(gdk_gl_drawable_get_gl_config(XEN_TO_C_GdkGLDrawable_(gldrawable))));
}
static XEN gxg_gdk_gl_drawable_get_size(XEN gldrawable, XEN width, XEN height)
{
#define H_gdk_gl_drawable_get_size "void gdk_gl_drawable_get_size(GdkGLDrawable* gldrawable, gint* [width], \
gint* [height])"
gint ref_width[1];
gint ref_height[1];
XEN_ASSERT_TYPE(XEN_GdkGLDrawable__P(gldrawable), gldrawable, 1, "gdk_gl_drawable_get_size", "GdkGLDrawable*");
gdk_gl_drawable_get_size(XEN_TO_C_GdkGLDrawable_(gldrawable), ref_width, ref_height);
return(XEN_LIST_2(C_TO_XEN_gint(ref_width[0]), C_TO_XEN_gint(ref_height[0])));
}
static XEN gxg_gdk_gl_pixmap_new(XEN glconfig, XEN pixmap, XEN attrib_list)
{
#define H_gdk_gl_pixmap_new "GdkGLPixmap* gdk_gl_pixmap_new(GdkGLConfig* glconfig, GdkPixmap* pixmap, \
int* attrib_list)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_pixmap_new", "GdkGLConfig*");
XEN_ASSERT_TYPE(XEN_GdkPixmap__P(pixmap), pixmap, 2, "gdk_gl_pixmap_new", "GdkPixmap*");
XEN_ASSERT_TYPE(XEN_int__P(attrib_list), attrib_list, 3, "gdk_gl_pixmap_new", "int*");
return(C_TO_XEN_GdkGLPixmap_(gdk_gl_pixmap_new(XEN_TO_C_GdkGLConfig_(glconfig), XEN_TO_C_GdkPixmap_(pixmap), XEN_TO_C_int_(attrib_list))));
}
static XEN gxg_gdk_gl_pixmap_get_pixmap(XEN glpixmap)
{
#define H_gdk_gl_pixmap_get_pixmap "GdkPixmap* gdk_gl_pixmap_get_pixmap(GdkGLPixmap* glpixmap)"
XEN_ASSERT_TYPE(XEN_GdkGLPixmap__P(glpixmap), glpixmap, 1, "gdk_gl_pixmap_get_pixmap", "GdkGLPixmap*");
return(C_TO_XEN_GdkPixmap_(gdk_gl_pixmap_get_pixmap(XEN_TO_C_GdkGLPixmap_(glpixmap))));
}
static XEN gxg_gdk_pixmap_set_gl_capability(XEN pixmap, XEN glconfig, XEN attrib_list)
{
#define H_gdk_pixmap_set_gl_capability "GdkGLPixmap* gdk_pixmap_set_gl_capability(GdkPixmap* pixmap, \
GdkGLConfig* glconfig, int* attrib_list)"
XEN_ASSERT_TYPE(XEN_GdkPixmap__P(pixmap), pixmap, 1, "gdk_pixmap_set_gl_capability", "GdkPixmap*");
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 2, "gdk_pixmap_set_gl_capability", "GdkGLConfig*");
XEN_ASSERT_TYPE(XEN_int__P(attrib_list), attrib_list, 3, "gdk_pixmap_set_gl_capability", "int*");
return(C_TO_XEN_GdkGLPixmap_(gdk_pixmap_set_gl_capability(XEN_TO_C_GdkPixmap_(pixmap), XEN_TO_C_GdkGLConfig_(glconfig),
XEN_TO_C_int_(attrib_list))));
}
static XEN gxg_gdk_pixmap_unset_gl_capability(XEN pixmap)
{
#define H_gdk_pixmap_unset_gl_capability "void gdk_pixmap_unset_gl_capability(GdkPixmap* pixmap)"
XEN_ASSERT_TYPE(XEN_GdkPixmap__P(pixmap), pixmap, 1, "gdk_pixmap_unset_gl_capability", "GdkPixmap*");
gdk_pixmap_unset_gl_capability(XEN_TO_C_GdkPixmap_(pixmap));
return(XEN_FALSE);
}
static XEN gxg_gdk_pixmap_is_gl_capable(XEN pixmap)
{
#define H_gdk_pixmap_is_gl_capable "gboolean gdk_pixmap_is_gl_capable(GdkPixmap* pixmap)"
XEN_ASSERT_TYPE(XEN_GdkPixmap__P(pixmap), pixmap, 1, "gdk_pixmap_is_gl_capable", "GdkPixmap*");
return(C_TO_XEN_gboolean(gdk_pixmap_is_gl_capable(XEN_TO_C_GdkPixmap_(pixmap))));
}
static XEN gxg_gdk_pixmap_get_gl_pixmap(XEN pixmap)
{
#define H_gdk_pixmap_get_gl_pixmap "GdkGLPixmap* gdk_pixmap_get_gl_pixmap(GdkPixmap* pixmap)"
XEN_ASSERT_TYPE(XEN_GdkPixmap__P(pixmap), pixmap, 1, "gdk_pixmap_get_gl_pixmap", "GdkPixmap*");
return(C_TO_XEN_GdkGLPixmap_(gdk_pixmap_get_gl_pixmap(XEN_TO_C_GdkPixmap_(pixmap))));
}
static XEN gxg_gdk_gl_window_new(XEN glconfig, XEN window, XEN attrib_list)
{
#define H_gdk_gl_window_new "GdkGLWindow* gdk_gl_window_new(GdkGLConfig* glconfig, GdkWindow* window, \
int* attrib_list)"
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 1, "gdk_gl_window_new", "GdkGLConfig*");
XEN_ASSERT_TYPE(XEN_GdkWindow__P(window), window, 2, "gdk_gl_window_new", "GdkWindow*");
XEN_ASSERT_TYPE(XEN_int__P(attrib_list), attrib_list, 3, "gdk_gl_window_new", "int*");
return(C_TO_XEN_GdkGLWindow_(gdk_gl_window_new(XEN_TO_C_GdkGLConfig_(glconfig), XEN_TO_C_GdkWindow_(window), XEN_TO_C_int_(attrib_list))));
}
static XEN gxg_gdk_gl_window_get_window(XEN glwindow)
{
#define H_gdk_gl_window_get_window "GdkWindow* gdk_gl_window_get_window(GdkGLWindow* glwindow)"
XEN_ASSERT_TYPE(XEN_GdkGLWindow__P(glwindow), glwindow, 1, "gdk_gl_window_get_window", "GdkGLWindow*");
return(C_TO_XEN_GdkWindow_(gdk_gl_window_get_window(XEN_TO_C_GdkGLWindow_(glwindow))));
}
static XEN gxg_gdk_window_set_gl_capability(XEN window, XEN glconfig, XEN attrib_list)
{
#define H_gdk_window_set_gl_capability "GdkGLWindow* gdk_window_set_gl_capability(GdkWindow* window, \
GdkGLConfig* glconfig, int* attrib_list)"
XEN_ASSERT_TYPE(XEN_GdkWindow__P(window), window, 1, "gdk_window_set_gl_capability", "GdkWindow*");
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 2, "gdk_window_set_gl_capability", "GdkGLConfig*");
XEN_ASSERT_TYPE(XEN_int__P(attrib_list), attrib_list, 3, "gdk_window_set_gl_capability", "int*");
return(C_TO_XEN_GdkGLWindow_(gdk_window_set_gl_capability(XEN_TO_C_GdkWindow_(window), XEN_TO_C_GdkGLConfig_(glconfig),
XEN_TO_C_int_(attrib_list))));
}
static XEN gxg_gdk_window_unset_gl_capability(XEN window)
{
#define H_gdk_window_unset_gl_capability "void gdk_window_unset_gl_capability(GdkWindow* window)"
XEN_ASSERT_TYPE(XEN_GdkWindow__P(window), window, 1, "gdk_window_unset_gl_capability", "GdkWindow*");
gdk_window_unset_gl_capability(XEN_TO_C_GdkWindow_(window));
return(XEN_FALSE);
}
static XEN gxg_gdk_window_is_gl_capable(XEN window)
{
#define H_gdk_window_is_gl_capable "gboolean gdk_window_is_gl_capable(GdkWindow* window)"
XEN_ASSERT_TYPE(XEN_GdkWindow__P(window), window, 1, "gdk_window_is_gl_capable", "GdkWindow*");
return(C_TO_XEN_gboolean(gdk_window_is_gl_capable(XEN_TO_C_GdkWindow_(window))));
}
static XEN gxg_gdk_window_get_gl_window(XEN window)
{
#define H_gdk_window_get_gl_window "GdkGLWindow* gdk_window_get_gl_window(GdkWindow* window)"
XEN_ASSERT_TYPE(XEN_GdkWindow__P(window), window, 1, "gdk_window_get_gl_window", "GdkWindow*");
return(C_TO_XEN_GdkGLWindow_(gdk_window_get_gl_window(XEN_TO_C_GdkWindow_(window))));
}
static XEN gxg_gdk_gl_font_use_pango_font(XEN font_desc, XEN first, XEN count, XEN list_base)
{
#define H_gdk_gl_font_use_pango_font "PangoFont* gdk_gl_font_use_pango_font(PangoFontDescription* font_desc, \
int first, int count, int list_base)"
XEN_ASSERT_TYPE(XEN_PangoFontDescription__P(font_desc), font_desc, 1, "gdk_gl_font_use_pango_font", "PangoFontDescription*");
XEN_ASSERT_TYPE(XEN_int_P(first), first, 2, "gdk_gl_font_use_pango_font", "int");
XEN_ASSERT_TYPE(XEN_int_P(count), count, 3, "gdk_gl_font_use_pango_font", "int");
XEN_ASSERT_TYPE(XEN_int_P(list_base), list_base, 4, "gdk_gl_font_use_pango_font", "int");
return(C_TO_XEN_PangoFont_(gdk_gl_font_use_pango_font(XEN_TO_C_PangoFontDescription_(font_desc), XEN_TO_C_int(first), XEN_TO_C_int(count),
XEN_TO_C_int(list_base))));
}
static XEN gxg_gtk_widget_set_gl_capability(XEN widget, XEN glconfig, XEN share_list, XEN direct, XEN render_type)
{
#define H_gtk_widget_set_gl_capability "gboolean gtk_widget_set_gl_capability(GtkWidget* widget, GdkGLConfig* glconfig, \
GdkGLContext* share_list, gboolean direct, int render_type)"
XEN_ASSERT_TYPE(XEN_GtkWidget__P(widget), widget, 1, "gtk_widget_set_gl_capability", "GtkWidget*");
XEN_ASSERT_TYPE(XEN_GdkGLConfig__P(glconfig), glconfig, 2, "gtk_widget_set_gl_capability", "GdkGLConfig*");
XEN_ASSERT_TYPE(XEN_GdkGLContext__P(share_list), share_list, 3, "gtk_widget_set_gl_capability", "GdkGLContext*");
XEN_ASSERT_TYPE(XEN_gboolean_P(direct), direct, 4, "gtk_widget_set_gl_capability", "gboolean");
XEN_ASSERT_TYPE(XEN_int_P(render_type), render_type, 5, "gtk_widget_set_gl_capability", "int");
return(C_TO_XEN_gboolean(gtk_widget_set_gl_capability(XEN_TO_C_GtkWidget_(widget), XEN_TO_C_GdkGLConfig_(glconfig), XEN_TO_C_GdkGLContext_(share_list),
XEN_TO_C_gboolean(direct), XEN_TO_C_int(render_type))));
}
static XEN gxg_gtk_widget_is_gl_capable(XEN widget)
{
#define H_gtk_widget_is_gl_capable "gboolean gtk_widget_is_gl_capable(GtkWidget* widget)"
XEN_ASSERT_TYPE(XEN_GtkWidget__P(widget), widget, 1, "gtk_widget_is_gl_capable", "GtkWidget*");
return(C_TO_XEN_gboolean(gtk_widget_is_gl_capable(XEN_TO_C_GtkWidget_(widget))));
}
static XEN gxg_gtk_widget_get_gl_config(XEN widget)
{
#define H_gtk_widget_get_gl_config "GdkGLConfig* gtk_widget_get_gl_config(GtkWidget* widget)"
XEN_ASSERT_TYPE(XEN_GtkWidget__P(widget), widget, 1, "gtk_widget_get_gl_config", "GtkWidget*");
return(C_TO_XEN_GdkGLConfig_(gtk_widget_get_gl_config(XEN_TO_C_GtkWidget_(widget))));
}
static XEN gxg_gtk_widget_get_gl_context(XEN widget)
{
#define H_gtk_widget_get_gl_context "GdkGLContext* gtk_widget_get_gl_context(GtkWidget* widget)"
XEN_ASSERT_TYPE(XEN_GtkWidget__P(widget), widget, 1, "gtk_widget_get_gl_context", "GtkWidget*");
return(C_TO_XEN_GdkGLContext_(gtk_widget_get_gl_context(XEN_TO_C_GtkWidget_(widget))));
}
static XEN gxg_gtk_widget_get_gl_window(XEN widget)
{
#define H_gtk_widget_get_gl_window "GdkGLWindow* gtk_widget_get_gl_window(GtkWidget* widget)"
XEN_ASSERT_TYPE(XEN_GtkWidget__P(widget), widget, 1, "gtk_widget_get_gl_window", "GtkWidget*");
return(C_TO_XEN_GdkGLWindow_(gtk_widget_get_gl_window(XEN_TO_C_GtkWidget_(widget))));
}
#ifdef GTKGLEXT_MAJOR_VERSION
static XEN gxg_gdk_gl_drawable_gl_begin(XEN gldrawable, XEN glcontext)
{
#define H_gdk_gl_drawable_gl_begin "gboolean gdk_gl_drawable_gl_begin(GdkGLDrawable* gldrawable, GdkGLContext* glcontext)"
XEN_ASSERT_TYPE(XEN_GdkGLDrawable__P(gldrawable), gldrawable, 1, "gdk_gl_drawable_gl_begin", "GdkGLDrawable*");
XEN_ASSERT_TYPE(XEN_GdkGLContext__P(glcontext), glcontext, 2, "gdk_gl_drawable_gl_begin", "GdkGLContext*");
return(C_TO_XEN_gboolean(gdk_gl_drawable_gl_begin(XEN_TO_C_GdkGLDrawable_(gldrawable), XEN_TO_C_GdkGLContext_(glcontext))));
}
static XEN gxg_gdk_gl_drawable_gl_end(XEN gldrawable)
{
#define H_gdk_gl_drawable_gl_end "void gdk_gl_drawable_gl_end(GdkGLDrawable* gldrawable)"
XEN_ASSERT_TYPE(XEN_GdkGLDrawable__P(gldrawable), gldrawable, 1, "gdk_gl_drawable_gl_end", "GdkGLDrawable*");
gdk_gl_drawable_gl_end(XEN_TO_C_GdkGLDrawable_(gldrawable));
return(XEN_FALSE);
}
#endif
#endif
static XEN gxg_glClearIndex(XEN c)
{
#define H_glClearIndex "void glClearIndex(GLfloat c)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(c), c, 1, "glClearIndex", "GLfloat");
glClearIndex(XEN_TO_C_GLfloat(c));
return(XEN_FALSE);
}
static XEN gxg_glClearColor(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glClearColor "void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)"
XEN_ASSERT_TYPE(XEN_GLclampf_P(red), red, 1, "glClearColor", "GLclampf");
XEN_ASSERT_TYPE(XEN_GLclampf_P(green), green, 2, "glClearColor", "GLclampf");
XEN_ASSERT_TYPE(XEN_GLclampf_P(blue), blue, 3, "glClearColor", "GLclampf");
XEN_ASSERT_TYPE(XEN_GLclampf_P(alpha), alpha, 4, "glClearColor", "GLclampf");
glClearColor(XEN_TO_C_GLclampf(red), XEN_TO_C_GLclampf(green), XEN_TO_C_GLclampf(blue), XEN_TO_C_GLclampf(alpha));
return(XEN_FALSE);
}
static XEN gxg_glClear(XEN mask)
{
#define H_glClear "void glClear(GLbitfield mask)"
XEN_ASSERT_TYPE(XEN_GLbitfield_P(mask), mask, 1, "glClear", "GLbitfield");
glClear(XEN_TO_C_GLbitfield(mask));
return(XEN_FALSE);
}
static XEN gxg_glIndexMask(XEN mask)
{
#define H_glIndexMask "void glIndexMask(GLuint mask)"
XEN_ASSERT_TYPE(XEN_GLuint_P(mask), mask, 1, "glIndexMask", "GLuint");
glIndexMask(XEN_TO_C_GLuint(mask));
return(XEN_FALSE);
}
static XEN gxg_glColorMask(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glColorMask "void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)"
XEN_ASSERT_TYPE(XEN_GLboolean_P(red), red, 1, "glColorMask", "GLboolean");
XEN_ASSERT_TYPE(XEN_GLboolean_P(green), green, 2, "glColorMask", "GLboolean");
XEN_ASSERT_TYPE(XEN_GLboolean_P(blue), blue, 3, "glColorMask", "GLboolean");
XEN_ASSERT_TYPE(XEN_GLboolean_P(alpha), alpha, 4, "glColorMask", "GLboolean");
glColorMask(XEN_TO_C_GLboolean(red), XEN_TO_C_GLboolean(green), XEN_TO_C_GLboolean(blue), XEN_TO_C_GLboolean(alpha));
return(XEN_FALSE);
}
static XEN gxg_glAlphaFunc(XEN func, XEN ref)
{
#define H_glAlphaFunc "void glAlphaFunc(GLenum func, GLclampf ref)"
XEN_ASSERT_TYPE(XEN_GLenum_P(func), func, 1, "glAlphaFunc", "GLenum");
XEN_ASSERT_TYPE(XEN_GLclampf_P(ref), ref, 2, "glAlphaFunc", "GLclampf");
glAlphaFunc(XEN_TO_C_GLenum(func), XEN_TO_C_GLclampf(ref));
return(XEN_FALSE);
}
static XEN gxg_glBlendFunc(XEN sfactor, XEN dfactor)
{
#define H_glBlendFunc "void glBlendFunc(GLenum sfactor, GLenum dfactor)"
XEN_ASSERT_TYPE(XEN_GLenum_P(sfactor), sfactor, 1, "glBlendFunc", "GLenum");
XEN_ASSERT_TYPE(XEN_GLenum_P(dfactor), dfactor, 2, "glBlendFunc", "GLenum");
glBlendFunc(XEN_TO_C_GLenum(sfactor), XEN_TO_C_GLenum(dfactor));
return(XEN_FALSE);
}
static XEN gxg_glLogicOp(XEN opcode)
{
#define H_glLogicOp "void glLogicOp(GLenum opcode)"
XEN_ASSERT_TYPE(XEN_GLenum_P(opcode), opcode, 1, "glLogicOp", "GLenum");
glLogicOp(XEN_TO_C_GLenum(opcode));
return(XEN_FALSE);
}
static XEN gxg_glCullFace(XEN mode)
{
#define H_glCullFace "void glCullFace(GLenum mode)"
XEN_ASSERT_TYPE(XEN_GLenum_P(mode), mode, 1, "glCullFace", "GLenum");
glCullFace(XEN_TO_C_GLenum(mode));
return(XEN_FALSE);
}
static XEN gxg_glFrontFace(XEN mode)
{
#define H_glFrontFace "void glFrontFace(GLenum mode)"
XEN_ASSERT_TYPE(XEN_GLenum_P(mode), mode, 1, "glFrontFace", "GLenum");
glFrontFace(XEN_TO_C_GLenum(mode));
return(XEN_FALSE);
}
static XEN gxg_glPointSize(XEN size)
{
#define H_glPointSize "void glPointSize(GLfloat size)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(size), size, 1, "glPointSize", "GLfloat");
glPointSize(XEN_TO_C_GLfloat(size));
return(XEN_FALSE);
}
static XEN gxg_glLineWidth(XEN width)
{
#define H_glLineWidth "void glLineWidth(GLfloat width)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(width), width, 1, "glLineWidth", "GLfloat");
glLineWidth(XEN_TO_C_GLfloat(width));
return(XEN_FALSE);
}
static XEN gxg_glLineStipple(XEN factor, XEN pattern)
{
#define H_glLineStipple "void glLineStipple(GLint factor, GLushort pattern)"
XEN_ASSERT_TYPE(XEN_GLint_P(factor), factor, 1, "glLineStipple", "GLint");
XEN_ASSERT_TYPE(XEN_GLushort_P(pattern), pattern, 2, "glLineStipple", "GLushort");
glLineStipple(XEN_TO_C_GLint(factor), XEN_TO_C_GLushort(pattern));
return(XEN_FALSE);
}
static XEN gxg_glPolygonMode(XEN face, XEN mode)
{
#define H_glPolygonMode "void glPolygonMode(GLenum face, GLenum mode)"
XEN_ASSERT_TYPE(XEN_GLenum_P(face), face, 1, "glPolygonMode", "GLenum");
XEN_ASSERT_TYPE(XEN_GLenum_P(mode), mode, 2, "glPolygonMode", "GLenum");
glPolygonMode(XEN_TO_C_GLenum(face), XEN_TO_C_GLenum(mode));
return(XEN_FALSE);
}
static XEN gxg_glPolygonOffset(XEN factor, XEN units)
{
#define H_glPolygonOffset "void glPolygonOffset(GLfloat factor, GLfloat units)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(factor), factor, 1, "glPolygonOffset", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(units), units, 2, "glPolygonOffset", "GLfloat");
glPolygonOffset(XEN_TO_C_GLfloat(factor), XEN_TO_C_GLfloat(units));
return(XEN_FALSE);
}
static XEN gxg_glPolygonStipple(XEN mask)
{
#define H_glPolygonStipple "void glPolygonStipple(GLubyte* mask)"
XEN_ASSERT_TYPE(XEN_GLubyte__P(mask), mask, 1, "glPolygonStipple", "GLubyte*");
glPolygonStipple(XEN_TO_C_GLubyte_(mask));
return(XEN_FALSE);
}
static XEN gxg_glEdgeFlag(XEN flag)
{
#define H_glEdgeFlag "void glEdgeFlag(GLboolean flag)"
XEN_ASSERT_TYPE(XEN_GLboolean_P(flag), flag, 1, "glEdgeFlag", "GLboolean");
glEdgeFlag(XEN_TO_C_GLboolean(flag));
return(XEN_FALSE);
}
static XEN gxg_glScissor(XEN x, XEN y, XEN width, XEN height)
{
#define H_glScissor "void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)"
XEN_ASSERT_TYPE(XEN_GLint_P(x), x, 1, "glScissor", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(y), y, 2, "glScissor", "GLint");
XEN_ASSERT_TYPE(XEN_GLsizei_P(width), width, 3, "glScissor", "GLsizei");
XEN_ASSERT_TYPE(XEN_GLsizei_P(height), height, 4, "glScissor", "GLsizei");
glScissor(XEN_TO_C_GLint(x), XEN_TO_C_GLint(y), XEN_TO_C_GLsizei(width), XEN_TO_C_GLsizei(height));
return(XEN_FALSE);
}
static XEN gxg_glClipPlane(XEN plane, XEN equation)
{
#define H_glClipPlane "void glClipPlane(GLenum plane, GLdouble* equation)"
XEN_ASSERT_TYPE(XEN_GLenum_P(plane), plane, 1, "glClipPlane", "GLenum");
XEN_ASSERT_TYPE(XEN_GLdouble__P(equation), equation, 2, "glClipPlane", "GLdouble*");
glClipPlane(XEN_TO_C_GLenum(plane), XEN_TO_C_GLdouble_(equation));
return(XEN_FALSE);
}
static XEN gxg_glGetClipPlane(XEN plane, XEN equation)
{
#define H_glGetClipPlane "void glGetClipPlane(GLenum plane, GLdouble* [equation])"
GLdouble ref_equation[1];
XEN_ASSERT_TYPE(XEN_GLenum_P(plane), plane, 1, "glGetClipPlane", "GLenum");
glGetClipPlane(XEN_TO_C_GLenum(plane), ref_equation);
return(XEN_LIST_1(C_TO_XEN_GLdouble(ref_equation[0])));
}
static XEN gxg_glDrawBuffer(XEN mode)
{
#define H_glDrawBuffer "void glDrawBuffer(GLenum mode)"
XEN_ASSERT_TYPE(XEN_GLenum_P(mode), mode, 1, "glDrawBuffer", "GLenum");
glDrawBuffer(XEN_TO_C_GLenum(mode));
return(XEN_FALSE);
}
static XEN gxg_glReadBuffer(XEN mode)
{
#define H_glReadBuffer "void glReadBuffer(GLenum mode)"
XEN_ASSERT_TYPE(XEN_GLenum_P(mode), mode, 1, "glReadBuffer", "GLenum");
glReadBuffer(XEN_TO_C_GLenum(mode));
return(XEN_FALSE);
}
static XEN gxg_glEnable(XEN cap)
{
#define H_glEnable "void glEnable(GLenum cap)"
XEN_ASSERT_TYPE(XEN_GLenum_P(cap), cap, 1, "glEnable", "GLenum");
glEnable(XEN_TO_C_GLenum(cap));
return(XEN_FALSE);
}
static XEN gxg_glDisable(XEN cap)
{
#define H_glDisable "void glDisable(GLenum cap)"
XEN_ASSERT_TYPE(XEN_GLenum_P(cap), cap, 1, "glDisable", "GLenum");
glDisable(XEN_TO_C_GLenum(cap));
return(XEN_FALSE);
}
static XEN gxg_glIsEnabled(XEN cap)
{
#define H_glIsEnabled "GLboolean glIsEnabled(GLenum cap)"
XEN_ASSERT_TYPE(XEN_GLenum_P(cap), cap, 1, "glIsEnabled", "GLenum");
return(C_TO_XEN_GLboolean(glIsEnabled(XEN_TO_C_GLenum(cap))));
}
static XEN gxg_glEnableClientState(XEN cap)
{
#define H_glEnableClientState "void glEnableClientState(GLenum cap)"
XEN_ASSERT_TYPE(XEN_GLenum_P(cap), cap, 1, "glEnableClientState", "GLenum");
glEnableClientState(XEN_TO_C_GLenum(cap));
return(XEN_FALSE);
}
static XEN gxg_glDisableClientState(XEN cap)
{
#define H_glDisableClientState "void glDisableClientState(GLenum cap)"
XEN_ASSERT_TYPE(XEN_GLenum_P(cap), cap, 1, "glDisableClientState", "GLenum");
glDisableClientState(XEN_TO_C_GLenum(cap));
return(XEN_FALSE);
}
static XEN gxg_glGetBooleanv(XEN pname, XEN params)
{
#define H_glGetBooleanv "void glGetBooleanv(GLenum pname, GLboolean* [params])"
GLboolean ref_params[16];
XEN_ASSERT_TYPE(XEN_GLenum_P(pname), pname, 1, "glGetBooleanv", "GLenum");
glGetBooleanv(XEN_TO_C_GLenum(pname), ref_params);
{
XEN result;
int i, vals;
vals = how_many_vals(XEN_TO_C_GLenum(pname));
result = XEN_EMPTY_LIST;
for (i = 0; i < vals; i++)
result = XEN_CONS(C_TO_XEN_GLboolean(ref_params[i]), result);
return(result);
}
}
static XEN gxg_glGetDoublev(XEN pname, XEN params)
{
#define H_glGetDoublev "void glGetDoublev(GLenum pname, GLdouble* [params])"
GLdouble ref_params[1];
XEN_ASSERT_TYPE(XEN_GLenum_P(pname), pname, 1, "glGetDoublev", "GLenum");
glGetDoublev(XEN_TO_C_GLenum(pname), ref_params);
return(XEN_LIST_1(C_TO_XEN_GLdouble(ref_params[0])));
}
static XEN gxg_glGetFloatv(XEN pname, XEN params)
{
#define H_glGetFloatv "void glGetFloatv(GLenum pname, GLfloat* [params])"
GLfloat ref_params[16];
XEN_ASSERT_TYPE(XEN_GLenum_P(pname), pname, 1, "glGetFloatv", "GLenum");
glGetFloatv(XEN_TO_C_GLenum(pname), ref_params);
{
XEN result;
int i, vals;
vals = how_many_vals(XEN_TO_C_GLenum(pname));
result = XEN_EMPTY_LIST;
for (i = 0; i < vals; i++)
result = XEN_CONS(C_TO_XEN_GLfloat(ref_params[i]), result);
return(result);
}
}
static XEN gxg_glGetIntegerv(XEN pname, XEN params)
{
#define H_glGetIntegerv "void glGetIntegerv(GLenum pname, GLint* [params])"
GLint ref_params[16];
XEN_ASSERT_TYPE(XEN_GLenum_P(pname), pname, 1, "glGetIntegerv", "GLenum");
glGetIntegerv(XEN_TO_C_GLenum(pname), ref_params);
{
XEN result;
int i, vals;
vals = how_many_vals(XEN_TO_C_GLenum(pname));
result = XEN_EMPTY_LIST;
for (i = 0; i < vals; i++)
result = XEN_CONS(C_TO_XEN_GLint(ref_params[i]), result);
return(result);
}
}
static XEN gxg_glPushAttrib(XEN mask)
{
#define H_glPushAttrib "void glPushAttrib(GLbitfield mask)"
XEN_ASSERT_TYPE(XEN_GLbitfield_P(mask), mask, 1, "glPushAttrib", "GLbitfield");
glPushAttrib(XEN_TO_C_GLbitfield(mask));
return(XEN_FALSE);
}
static XEN gxg_glPopAttrib(void)
{
#define H_glPopAttrib "void glPopAttrib( void)"
glPopAttrib();
return(XEN_FALSE);
}
static XEN gxg_glPushClientAttrib(XEN mask)
{
#define H_glPushClientAttrib "void glPushClientAttrib(GLbitfield mask)"
XEN_ASSERT_TYPE(XEN_GLbitfield_P(mask), mask, 1, "glPushClientAttrib", "GLbitfield");
glPushClientAttrib(XEN_TO_C_GLbitfield(mask));
return(XEN_FALSE);
}
static XEN gxg_glPopClientAttrib(void)
{
#define H_glPopClientAttrib "void glPopClientAttrib( void)"
glPopClientAttrib();
return(XEN_FALSE);
}
static XEN gxg_glRenderMode(XEN mode)
{
#define H_glRenderMode "GLint glRenderMode(GLenum mode)"
XEN_ASSERT_TYPE(XEN_GLenum_P(mode), mode, 1, "glRenderMode", "GLenum");
return(C_TO_XEN_GLint(glRenderMode(XEN_TO_C_GLenum(mode))));
}
static XEN gxg_glGetError(void)
{
#define H_glGetError "GLenum glGetError( void)"
return(C_TO_XEN_GLenum(glGetError()));
}
static XEN gxg_glGetString(XEN name)
{
#define H_glGetString "constchar* glGetString(GLenum name)"
XEN_ASSERT_TYPE(XEN_GLenum_P(name), name, 1, "glGetString", "GLenum");
return(C_TO_XEN_constchar_(glGetString(XEN_TO_C_GLenum(name))));
}
static XEN gxg_glFinish(void)
{
#define H_glFinish "void glFinish( void)"
glFinish();
return(XEN_FALSE);
}
static XEN gxg_glFlush(void)
{
#define H_glFlush "void glFlush( void)"
glFlush();
return(XEN_FALSE);
}
static XEN gxg_glHint(XEN target, XEN mode)
{
#define H_glHint "void glHint(GLenum target, GLenum mode)"
XEN_ASSERT_TYPE(XEN_GLenum_P(target), target, 1, "glHint", "GLenum");
XEN_ASSERT_TYPE(XEN_GLenum_P(mode), mode, 2, "glHint", "GLenum");
glHint(XEN_TO_C_GLenum(target), XEN_TO_C_GLenum(mode));
return(XEN_FALSE);
}
static XEN gxg_glClearDepth(XEN depth)
{
#define H_glClearDepth "void glClearDepth(GLclampd depth)"
XEN_ASSERT_TYPE(XEN_GLclampd_P(depth), depth, 1, "glClearDepth", "GLclampd");
glClearDepth(XEN_TO_C_GLclampd(depth));
return(XEN_FALSE);
}
static XEN gxg_glDepthFunc(XEN func)
{
#define H_glDepthFunc "void glDepthFunc(GLenum func)"
XEN_ASSERT_TYPE(XEN_GLenum_P(func), func, 1, "glDepthFunc", "GLenum");
glDepthFunc(XEN_TO_C_GLenum(func));
return(XEN_FALSE);
}
static XEN gxg_glDepthMask(XEN flag)
{
#define H_glDepthMask "void glDepthMask(GLboolean flag)"
XEN_ASSERT_TYPE(XEN_GLboolean_P(flag), flag, 1, "glDepthMask", "GLboolean");
glDepthMask(XEN_TO_C_GLboolean(flag));
return(XEN_FALSE);
}
static XEN gxg_glDepthRange(XEN near_val, XEN far_val)
{
#define H_glDepthRange "void glDepthRange(GLclampd near_val, GLclampd far_val)"
XEN_ASSERT_TYPE(XEN_GLclampd_P(near_val), near_val, 1, "glDepthRange", "GLclampd");
XEN_ASSERT_TYPE(XEN_GLclampd_P(far_val), far_val, 2, "glDepthRange", "GLclampd");
glDepthRange(XEN_TO_C_GLclampd(near_val), XEN_TO_C_GLclampd(far_val));
return(XEN_FALSE);
}
static XEN gxg_glClearAccum(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glClearAccum "void glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(red), red, 1, "glClearAccum", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(green), green, 2, "glClearAccum", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(blue), blue, 3, "glClearAccum", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(alpha), alpha, 4, "glClearAccum", "GLfloat");
glClearAccum(XEN_TO_C_GLfloat(red), XEN_TO_C_GLfloat(green), XEN_TO_C_GLfloat(blue), XEN_TO_C_GLfloat(alpha));
return(XEN_FALSE);
}
static XEN gxg_glAccum(XEN op, XEN value)
{
#define H_glAccum "void glAccum(GLenum op, GLfloat value)"
XEN_ASSERT_TYPE(XEN_GLenum_P(op), op, 1, "glAccum", "GLenum");
XEN_ASSERT_TYPE(XEN_GLfloat_P(value), value, 2, "glAccum", "GLfloat");
glAccum(XEN_TO_C_GLenum(op), XEN_TO_C_GLfloat(value));
return(XEN_FALSE);
}
static XEN gxg_glMatrixMode(XEN mode)
{
#define H_glMatrixMode "void glMatrixMode(GLenum mode)"
XEN_ASSERT_TYPE(XEN_GLenum_P(mode), mode, 1, "glMatrixMode", "GLenum");
glMatrixMode(XEN_TO_C_GLenum(mode));
return(XEN_FALSE);
}
static XEN gxg_glOrtho(XEN left, XEN right, XEN bottom, XEN top, XEN near_val, XEN far_val)
{
#define H_glOrtho "void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, \
GLdouble far_val)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(left), left, 1, "glOrtho", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(right), right, 2, "glOrtho", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(bottom), bottom, 3, "glOrtho", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(top), top, 4, "glOrtho", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(near_val), near_val, 5, "glOrtho", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(far_val), far_val, 6, "glOrtho", "GLdouble");
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),
XEN_TO_C_GLdouble(far_val));
return(XEN_FALSE);
}
static XEN gxg_glFrustum(XEN left, XEN right, XEN bottom, XEN top, XEN near_val, XEN far_val)
{
#define H_glFrustum "void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, \
GLdouble far_val)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(left), left, 1, "glFrustum", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(right), right, 2, "glFrustum", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(bottom), bottom, 3, "glFrustum", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(top), top, 4, "glFrustum", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(near_val), near_val, 5, "glFrustum", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(far_val), far_val, 6, "glFrustum", "GLdouble");
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),
XEN_TO_C_GLdouble(far_val));
return(XEN_FALSE);
}
static XEN gxg_glViewport(XEN x, XEN y, XEN width, XEN height)
{
#define H_glViewport "void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)"
XEN_ASSERT_TYPE(XEN_GLint_P(x), x, 1, "glViewport", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(y), y, 2, "glViewport", "GLint");
XEN_ASSERT_TYPE(XEN_GLsizei_P(width), width, 3, "glViewport", "GLsizei");
XEN_ASSERT_TYPE(XEN_GLsizei_P(height), height, 4, "glViewport", "GLsizei");
glViewport(XEN_TO_C_GLint(x), XEN_TO_C_GLint(y), XEN_TO_C_GLsizei(width), XEN_TO_C_GLsizei(height));
return(XEN_FALSE);
}
static XEN gxg_glPushMatrix(void)
{
#define H_glPushMatrix "void glPushMatrix( void)"
glPushMatrix();
return(XEN_FALSE);
}
static XEN gxg_glPopMatrix(void)
{
#define H_glPopMatrix "void glPopMatrix( void)"
glPopMatrix();
return(XEN_FALSE);
}
static XEN gxg_glLoadIdentity(void)
{
#define H_glLoadIdentity "void glLoadIdentity( void)"
glLoadIdentity();
return(XEN_FALSE);
}
static XEN gxg_glLoadMatrixd(XEN m)
{
#define H_glLoadMatrixd "void glLoadMatrixd(GLdouble* m)"
XEN_ASSERT_TYPE(XEN_GLdouble__P(m), m, 1, "glLoadMatrixd", "GLdouble*");
glLoadMatrixd(XEN_TO_C_GLdouble_(m));
return(XEN_FALSE);
}
static XEN gxg_glLoadMatrixf(XEN m)
{
#define H_glLoadMatrixf "void glLoadMatrixf(GLfloat* m)"
XEN_ASSERT_TYPE(XEN_GLfloat__P(m), m, 1, "glLoadMatrixf", "GLfloat*");
glLoadMatrixf(XEN_TO_C_GLfloat_(m));
return(XEN_FALSE);
}
static XEN gxg_glMultMatrixd(XEN m)
{
#define H_glMultMatrixd "void glMultMatrixd(GLdouble* m)"
XEN_ASSERT_TYPE(XEN_GLdouble__P(m), m, 1, "glMultMatrixd", "GLdouble*");
glMultMatrixd(XEN_TO_C_GLdouble_(m));
return(XEN_FALSE);
}
static XEN gxg_glMultMatrixf(XEN m)
{
#define H_glMultMatrixf "void glMultMatrixf(GLfloat* m)"
XEN_ASSERT_TYPE(XEN_GLfloat__P(m), m, 1, "glMultMatrixf", "GLfloat*");
glMultMatrixf(XEN_TO_C_GLfloat_(m));
return(XEN_FALSE);
}
static XEN gxg_glRotated(XEN angle, XEN x, XEN y, XEN z)
{
#define H_glRotated "void glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(angle), angle, 1, "glRotated", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(x), x, 2, "glRotated", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(y), y, 3, "glRotated", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(z), z, 4, "glRotated", "GLdouble");
glRotated(XEN_TO_C_GLdouble(angle), XEN_TO_C_GLdouble(x), XEN_TO_C_GLdouble(y), XEN_TO_C_GLdouble(z));
return(XEN_FALSE);
}
static XEN gxg_glRotatef(XEN angle, XEN x, XEN y, XEN z)
{
#define H_glRotatef "void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(angle), angle, 1, "glRotatef", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(x), x, 2, "glRotatef", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(y), y, 3, "glRotatef", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(z), z, 4, "glRotatef", "GLfloat");
glRotatef(XEN_TO_C_GLfloat(angle), XEN_TO_C_GLfloat(x), XEN_TO_C_GLfloat(y), XEN_TO_C_GLfloat(z));
return(XEN_FALSE);
}
static XEN gxg_glScaled(XEN x, XEN y, XEN z)
{
#define H_glScaled "void glScaled(GLdouble x, GLdouble y, GLdouble z)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(x), x, 1, "glScaled", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(y), y, 2, "glScaled", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(z), z, 3, "glScaled", "GLdouble");
glScaled(XEN_TO_C_GLdouble(x), XEN_TO_C_GLdouble(y), XEN_TO_C_GLdouble(z));
return(XEN_FALSE);
}
static XEN gxg_glScalef(XEN x, XEN y, XEN z)
{
#define H_glScalef "void glScalef(GLfloat x, GLfloat y, GLfloat z)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(x), x, 1, "glScalef", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(y), y, 2, "glScalef", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(z), z, 3, "glScalef", "GLfloat");
glScalef(XEN_TO_C_GLfloat(x), XEN_TO_C_GLfloat(y), XEN_TO_C_GLfloat(z));
return(XEN_FALSE);
}
static XEN gxg_glTranslated(XEN x, XEN y, XEN z)
{
#define H_glTranslated "void glTranslated(GLdouble x, GLdouble y, GLdouble z)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(x), x, 1, "glTranslated", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(y), y, 2, "glTranslated", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(z), z, 3, "glTranslated", "GLdouble");
glTranslated(XEN_TO_C_GLdouble(x), XEN_TO_C_GLdouble(y), XEN_TO_C_GLdouble(z));
return(XEN_FALSE);
}
static XEN gxg_glTranslatef(XEN x, XEN y, XEN z)
{
#define H_glTranslatef "void glTranslatef(GLfloat x, GLfloat y, GLfloat z)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(x), x, 1, "glTranslatef", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(y), y, 2, "glTranslatef", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(z), z, 3, "glTranslatef", "GLfloat");
glTranslatef(XEN_TO_C_GLfloat(x), XEN_TO_C_GLfloat(y), XEN_TO_C_GLfloat(z));
return(XEN_FALSE);
}
static XEN gxg_glIsList(XEN list)
{
#define H_glIsList "GLboolean glIsList(GLuint list)"
XEN_ASSERT_TYPE(XEN_GLuint_P(list), list, 1, "glIsList", "GLuint");
return(C_TO_XEN_GLboolean(glIsList(XEN_TO_C_GLuint(list))));
}
static XEN gxg_glDeleteLists(XEN list, XEN range)
{
#define H_glDeleteLists "void glDeleteLists(GLuint list, GLsizei range)"
XEN_ASSERT_TYPE(XEN_GLuint_P(list), list, 1, "glDeleteLists", "GLuint");
XEN_ASSERT_TYPE(XEN_GLsizei_P(range), range, 2, "glDeleteLists", "GLsizei");
glDeleteLists(XEN_TO_C_GLuint(list), XEN_TO_C_GLsizei(range));
return(XEN_FALSE);
}
static XEN gxg_glGenLists(XEN range)
{
#define H_glGenLists "GLuint glGenLists(GLsizei range)"
XEN_ASSERT_TYPE(XEN_GLsizei_P(range), range, 1, "glGenLists", "GLsizei");
return(C_TO_XEN_GLuint(glGenLists(XEN_TO_C_GLsizei(range))));
}
static XEN gxg_glNewList(XEN list, XEN mode)
{
#define H_glNewList "void glNewList(GLuint list, GLenum mode)"
XEN_ASSERT_TYPE(XEN_GLuint_P(list), list, 1, "glNewList", "GLuint");
XEN_ASSERT_TYPE(XEN_GLenum_P(mode), mode, 2, "glNewList", "GLenum");
glNewList(XEN_TO_C_GLuint(list), XEN_TO_C_GLenum(mode));
return(XEN_FALSE);
}
static XEN gxg_glEndList(void)
{
#define H_glEndList "void glEndList( void)"
glEndList();
return(XEN_FALSE);
}
static XEN gxg_glCallList(XEN list)
{
#define H_glCallList "void glCallList(GLuint list)"
XEN_ASSERT_TYPE(XEN_GLuint_P(list), list, 1, "glCallList", "GLuint");
glCallList(XEN_TO_C_GLuint(list));
return(XEN_FALSE);
}
static XEN gxg_glCallLists(XEN n, XEN type, XEN lists)
{
#define H_glCallLists "void glCallLists(GLsizei n, GLenum type, GLvoid* lists)"
XEN_ASSERT_TYPE(XEN_GLsizei_P(n), n, 1, "glCallLists", "GLsizei");
XEN_ASSERT_TYPE(XEN_GLenum_P(type), type, 2, "glCallLists", "GLenum");
XEN_ASSERT_TYPE(XEN_GLvoid__P(lists), lists, 3, "glCallLists", "GLvoid*");
glCallLists(XEN_TO_C_GLsizei(n), XEN_TO_C_GLenum(type), XEN_TO_C_GLvoid_(lists));
return(XEN_FALSE);
}
static XEN gxg_glListBase(XEN base)
{
#define H_glListBase "void glListBase(GLuint base)"
XEN_ASSERT_TYPE(XEN_GLuint_P(base), base, 1, "glListBase", "GLuint");
glListBase(XEN_TO_C_GLuint(base));
return(XEN_FALSE);
}
static XEN gxg_glBegin(XEN mode)
{
#define H_glBegin "void glBegin(GLenum mode)"
XEN_ASSERT_TYPE(XEN_GLenum_P(mode), mode, 1, "glBegin", "GLenum");
glBegin(XEN_TO_C_GLenum(mode));
return(XEN_FALSE);
}
static XEN gxg_glEnd(void)
{
#define H_glEnd "void glEnd( void)"
glEnd();
return(XEN_FALSE);
}
static XEN gxg_glVertex2d(XEN x, XEN y)
{
#define H_glVertex2d "void glVertex2d(GLdouble x, GLdouble y)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(x), x, 1, "glVertex2d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(y), y, 2, "glVertex2d", "GLdouble");
glVertex2d(XEN_TO_C_GLdouble(x), XEN_TO_C_GLdouble(y));
return(XEN_FALSE);
}
static XEN gxg_glVertex2f(XEN x, XEN y)
{
#define H_glVertex2f "void glVertex2f(GLfloat x, GLfloat y)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(x), x, 1, "glVertex2f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(y), y, 2, "glVertex2f", "GLfloat");
glVertex2f(XEN_TO_C_GLfloat(x), XEN_TO_C_GLfloat(y));
return(XEN_FALSE);
}
static XEN gxg_glVertex2i(XEN x, XEN y)
{
#define H_glVertex2i "void glVertex2i(GLint x, GLint y)"
XEN_ASSERT_TYPE(XEN_GLint_P(x), x, 1, "glVertex2i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(y), y, 2, "glVertex2i", "GLint");
glVertex2i(XEN_TO_C_GLint(x), XEN_TO_C_GLint(y));
return(XEN_FALSE);
}
static XEN gxg_glVertex2s(XEN x, XEN y)
{
#define H_glVertex2s "void glVertex2s(GLshort x, GLshort y)"
XEN_ASSERT_TYPE(XEN_GLshort_P(x), x, 1, "glVertex2s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(y), y, 2, "glVertex2s", "GLshort");
glVertex2s(XEN_TO_C_GLshort(x), XEN_TO_C_GLshort(y));
return(XEN_FALSE);
}
static XEN gxg_glVertex3d(XEN x, XEN y, XEN z)
{
#define H_glVertex3d "void glVertex3d(GLdouble x, GLdouble y, GLdouble z)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(x), x, 1, "glVertex3d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(y), y, 2, "glVertex3d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(z), z, 3, "glVertex3d", "GLdouble");
glVertex3d(XEN_TO_C_GLdouble(x), XEN_TO_C_GLdouble(y), XEN_TO_C_GLdouble(z));
return(XEN_FALSE);
}
static XEN gxg_glVertex3f(XEN x, XEN y, XEN z)
{
#define H_glVertex3f "void glVertex3f(GLfloat x, GLfloat y, GLfloat z)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(x), x, 1, "glVertex3f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(y), y, 2, "glVertex3f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(z), z, 3, "glVertex3f", "GLfloat");
glVertex3f(XEN_TO_C_GLfloat(x), XEN_TO_C_GLfloat(y), XEN_TO_C_GLfloat(z));
return(XEN_FALSE);
}
static XEN gxg_glVertex3i(XEN x, XEN y, XEN z)
{
#define H_glVertex3i "void glVertex3i(GLint x, GLint y, GLint z)"
XEN_ASSERT_TYPE(XEN_GLint_P(x), x, 1, "glVertex3i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(y), y, 2, "glVertex3i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(z), z, 3, "glVertex3i", "GLint");
glVertex3i(XEN_TO_C_GLint(x), XEN_TO_C_GLint(y), XEN_TO_C_GLint(z));
return(XEN_FALSE);
}
static XEN gxg_glVertex3s(XEN x, XEN y, XEN z)
{
#define H_glVertex3s "void glVertex3s(GLshort x, GLshort y, GLshort z)"
XEN_ASSERT_TYPE(XEN_GLshort_P(x), x, 1, "glVertex3s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(y), y, 2, "glVertex3s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(z), z, 3, "glVertex3s", "GLshort");
glVertex3s(XEN_TO_C_GLshort(x), XEN_TO_C_GLshort(y), XEN_TO_C_GLshort(z));
return(XEN_FALSE);
}
static XEN gxg_glVertex4d(XEN x, XEN y, XEN z, XEN w)
{
#define H_glVertex4d "void glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(x), x, 1, "glVertex4d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(y), y, 2, "glVertex4d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(z), z, 3, "glVertex4d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(w), w, 4, "glVertex4d", "GLdouble");
glVertex4d(XEN_TO_C_GLdouble(x), XEN_TO_C_GLdouble(y), XEN_TO_C_GLdouble(z), XEN_TO_C_GLdouble(w));
return(XEN_FALSE);
}
static XEN gxg_glVertex4f(XEN x, XEN y, XEN z, XEN w)
{
#define H_glVertex4f "void glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(x), x, 1, "glVertex4f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(y), y, 2, "glVertex4f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(z), z, 3, "glVertex4f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(w), w, 4, "glVertex4f", "GLfloat");
glVertex4f(XEN_TO_C_GLfloat(x), XEN_TO_C_GLfloat(y), XEN_TO_C_GLfloat(z), XEN_TO_C_GLfloat(w));
return(XEN_FALSE);
}
static XEN gxg_glVertex4i(XEN x, XEN y, XEN z, XEN w)
{
#define H_glVertex4i "void glVertex4i(GLint x, GLint y, GLint z, GLint w)"
XEN_ASSERT_TYPE(XEN_GLint_P(x), x, 1, "glVertex4i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(y), y, 2, "glVertex4i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(z), z, 3, "glVertex4i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(w), w, 4, "glVertex4i", "GLint");
glVertex4i(XEN_TO_C_GLint(x), XEN_TO_C_GLint(y), XEN_TO_C_GLint(z), XEN_TO_C_GLint(w));
return(XEN_FALSE);
}
static XEN gxg_glVertex4s(XEN x, XEN y, XEN z, XEN w)
{
#define H_glVertex4s "void glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)"
XEN_ASSERT_TYPE(XEN_GLshort_P(x), x, 1, "glVertex4s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(y), y, 2, "glVertex4s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(z), z, 3, "glVertex4s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(w), w, 4, "glVertex4s", "GLshort");
glVertex4s(XEN_TO_C_GLshort(x), XEN_TO_C_GLshort(y), XEN_TO_C_GLshort(z), XEN_TO_C_GLshort(w));
return(XEN_FALSE);
}
static XEN gxg_glNormal3b(XEN nx, XEN ny, XEN nz)
{
#define H_glNormal3b "void glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)"
XEN_ASSERT_TYPE(XEN_GLbyte_P(nx), nx, 1, "glNormal3b", "GLbyte");
XEN_ASSERT_TYPE(XEN_GLbyte_P(ny), ny, 2, "glNormal3b", "GLbyte");
XEN_ASSERT_TYPE(XEN_GLbyte_P(nz), nz, 3, "glNormal3b", "GLbyte");
glNormal3b(XEN_TO_C_GLbyte(nx), XEN_TO_C_GLbyte(ny), XEN_TO_C_GLbyte(nz));
return(XEN_FALSE);
}
static XEN gxg_glNormal3d(XEN nx, XEN ny, XEN nz)
{
#define H_glNormal3d "void glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(nx), nx, 1, "glNormal3d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(ny), ny, 2, "glNormal3d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(nz), nz, 3, "glNormal3d", "GLdouble");
glNormal3d(XEN_TO_C_GLdouble(nx), XEN_TO_C_GLdouble(ny), XEN_TO_C_GLdouble(nz));
return(XEN_FALSE);
}
static XEN gxg_glNormal3f(XEN nx, XEN ny, XEN nz)
{
#define H_glNormal3f "void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(nx), nx, 1, "glNormal3f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(ny), ny, 2, "glNormal3f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(nz), nz, 3, "glNormal3f", "GLfloat");
glNormal3f(XEN_TO_C_GLfloat(nx), XEN_TO_C_GLfloat(ny), XEN_TO_C_GLfloat(nz));
return(XEN_FALSE);
}
static XEN gxg_glNormal3i(XEN nx, XEN ny, XEN nz)
{
#define H_glNormal3i "void glNormal3i(GLint nx, GLint ny, GLint nz)"
XEN_ASSERT_TYPE(XEN_GLint_P(nx), nx, 1, "glNormal3i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(ny), ny, 2, "glNormal3i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(nz), nz, 3, "glNormal3i", "GLint");
glNormal3i(XEN_TO_C_GLint(nx), XEN_TO_C_GLint(ny), XEN_TO_C_GLint(nz));
return(XEN_FALSE);
}
static XEN gxg_glNormal3s(XEN nx, XEN ny, XEN nz)
{
#define H_glNormal3s "void glNormal3s(GLshort nx, GLshort ny, GLshort nz)"
XEN_ASSERT_TYPE(XEN_GLshort_P(nx), nx, 1, "glNormal3s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(ny), ny, 2, "glNormal3s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(nz), nz, 3, "glNormal3s", "GLshort");
glNormal3s(XEN_TO_C_GLshort(nx), XEN_TO_C_GLshort(ny), XEN_TO_C_GLshort(nz));
return(XEN_FALSE);
}
static XEN gxg_glIndexd(XEN c)
{
#define H_glIndexd "void glIndexd(GLdouble c)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(c), c, 1, "glIndexd", "GLdouble");
glIndexd(XEN_TO_C_GLdouble(c));
return(XEN_FALSE);
}
static XEN gxg_glIndexf(XEN c)
{
#define H_glIndexf "void glIndexf(GLfloat c)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(c), c, 1, "glIndexf", "GLfloat");
glIndexf(XEN_TO_C_GLfloat(c));
return(XEN_FALSE);
}
static XEN gxg_glIndexi(XEN c)
{
#define H_glIndexi "void glIndexi(GLint c)"
XEN_ASSERT_TYPE(XEN_GLint_P(c), c, 1, "glIndexi", "GLint");
glIndexi(XEN_TO_C_GLint(c));
return(XEN_FALSE);
}
static XEN gxg_glIndexs(XEN c)
{
#define H_glIndexs "void glIndexs(GLshort c)"
XEN_ASSERT_TYPE(XEN_GLshort_P(c), c, 1, "glIndexs", "GLshort");
glIndexs(XEN_TO_C_GLshort(c));
return(XEN_FALSE);
}
static XEN gxg_glIndexub(XEN c)
{
#define H_glIndexub "void glIndexub(GLubyte c)"
XEN_ASSERT_TYPE(XEN_GLubyte_P(c), c, 1, "glIndexub", "GLubyte");
glIndexub(XEN_TO_C_GLubyte(c));
return(XEN_FALSE);
}
static XEN gxg_glColor3b(XEN red, XEN green, XEN blue)
{
#define H_glColor3b "void glColor3b(GLbyte red, GLbyte green, GLbyte blue)"
XEN_ASSERT_TYPE(XEN_GLbyte_P(red), red, 1, "glColor3b", "GLbyte");
XEN_ASSERT_TYPE(XEN_GLbyte_P(green), green, 2, "glColor3b", "GLbyte");
XEN_ASSERT_TYPE(XEN_GLbyte_P(blue), blue, 3, "glColor3b", "GLbyte");
glColor3b(XEN_TO_C_GLbyte(red), XEN_TO_C_GLbyte(green), XEN_TO_C_GLbyte(blue));
return(XEN_FALSE);
}
static XEN gxg_glColor3d(XEN red, XEN green, XEN blue)
{
#define H_glColor3d "void glColor3d(GLdouble red, GLdouble green, GLdouble blue)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(red), red, 1, "glColor3d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(green), green, 2, "glColor3d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(blue), blue, 3, "glColor3d", "GLdouble");
glColor3d(XEN_TO_C_GLdouble(red), XEN_TO_C_GLdouble(green), XEN_TO_C_GLdouble(blue));
return(XEN_FALSE);
}
static XEN gxg_glColor3f(XEN red, XEN green, XEN blue)
{
#define H_glColor3f "void glColor3f(GLfloat red, GLfloat green, GLfloat blue)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(red), red, 1, "glColor3f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(green), green, 2, "glColor3f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(blue), blue, 3, "glColor3f", "GLfloat");
glColor3f(XEN_TO_C_GLfloat(red), XEN_TO_C_GLfloat(green), XEN_TO_C_GLfloat(blue));
return(XEN_FALSE);
}
static XEN gxg_glColor3i(XEN red, XEN green, XEN blue)
{
#define H_glColor3i "void glColor3i(GLint red, GLint green, GLint blue)"
XEN_ASSERT_TYPE(XEN_GLint_P(red), red, 1, "glColor3i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(green), green, 2, "glColor3i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(blue), blue, 3, "glColor3i", "GLint");
glColor3i(XEN_TO_C_GLint(red), XEN_TO_C_GLint(green), XEN_TO_C_GLint(blue));
return(XEN_FALSE);
}
static XEN gxg_glColor3s(XEN red, XEN green, XEN blue)
{
#define H_glColor3s "void glColor3s(GLshort red, GLshort green, GLshort blue)"
XEN_ASSERT_TYPE(XEN_GLshort_P(red), red, 1, "glColor3s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(green), green, 2, "glColor3s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(blue), blue, 3, "glColor3s", "GLshort");
glColor3s(XEN_TO_C_GLshort(red), XEN_TO_C_GLshort(green), XEN_TO_C_GLshort(blue));
return(XEN_FALSE);
}
static XEN gxg_glColor3ub(XEN red, XEN green, XEN blue)
{
#define H_glColor3ub "void glColor3ub(GLubyte red, GLubyte green, GLubyte blue)"
XEN_ASSERT_TYPE(XEN_GLubyte_P(red), red, 1, "glColor3ub", "GLubyte");
XEN_ASSERT_TYPE(XEN_GLubyte_P(green), green, 2, "glColor3ub", "GLubyte");
XEN_ASSERT_TYPE(XEN_GLubyte_P(blue), blue, 3, "glColor3ub", "GLubyte");
glColor3ub(XEN_TO_C_GLubyte(red), XEN_TO_C_GLubyte(green), XEN_TO_C_GLubyte(blue));
return(XEN_FALSE);
}
static XEN gxg_glColor3ui(XEN red, XEN green, XEN blue)
{
#define H_glColor3ui "void glColor3ui(GLuint red, GLuint green, GLuint blue)"
XEN_ASSERT_TYPE(XEN_GLuint_P(red), red, 1, "glColor3ui", "GLuint");
XEN_ASSERT_TYPE(XEN_GLuint_P(green), green, 2, "glColor3ui", "GLuint");
XEN_ASSERT_TYPE(XEN_GLuint_P(blue), blue, 3, "glColor3ui", "GLuint");
glColor3ui(XEN_TO_C_GLuint(red), XEN_TO_C_GLuint(green), XEN_TO_C_GLuint(blue));
return(XEN_FALSE);
}
static XEN gxg_glColor3us(XEN red, XEN green, XEN blue)
{
#define H_glColor3us "void glColor3us(GLushort red, GLushort green, GLushort blue)"
XEN_ASSERT_TYPE(XEN_GLushort_P(red), red, 1, "glColor3us", "GLushort");
XEN_ASSERT_TYPE(XEN_GLushort_P(green), green, 2, "glColor3us", "GLushort");
XEN_ASSERT_TYPE(XEN_GLushort_P(blue), blue, 3, "glColor3us", "GLushort");
glColor3us(XEN_TO_C_GLushort(red), XEN_TO_C_GLushort(green), XEN_TO_C_GLushort(blue));
return(XEN_FALSE);
}
static XEN gxg_glColor4b(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glColor4b "void glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)"
XEN_ASSERT_TYPE(XEN_GLbyte_P(red), red, 1, "glColor4b", "GLbyte");
XEN_ASSERT_TYPE(XEN_GLbyte_P(green), green, 2, "glColor4b", "GLbyte");
XEN_ASSERT_TYPE(XEN_GLbyte_P(blue), blue, 3, "glColor4b", "GLbyte");
XEN_ASSERT_TYPE(XEN_GLbyte_P(alpha), alpha, 4, "glColor4b", "GLbyte");
glColor4b(XEN_TO_C_GLbyte(red), XEN_TO_C_GLbyte(green), XEN_TO_C_GLbyte(blue), XEN_TO_C_GLbyte(alpha));
return(XEN_FALSE);
}
static XEN gxg_glColor4d(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glColor4d "void glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(red), red, 1, "glColor4d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(green), green, 2, "glColor4d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(blue), blue, 3, "glColor4d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(alpha), alpha, 4, "glColor4d", "GLdouble");
glColor4d(XEN_TO_C_GLdouble(red), XEN_TO_C_GLdouble(green), XEN_TO_C_GLdouble(blue), XEN_TO_C_GLdouble(alpha));
return(XEN_FALSE);
}
static XEN gxg_glColor4f(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glColor4f "void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(red), red, 1, "glColor4f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(green), green, 2, "glColor4f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(blue), blue, 3, "glColor4f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(alpha), alpha, 4, "glColor4f", "GLfloat");
glColor4f(XEN_TO_C_GLfloat(red), XEN_TO_C_GLfloat(green), XEN_TO_C_GLfloat(blue), XEN_TO_C_GLfloat(alpha));
return(XEN_FALSE);
}
static XEN gxg_glColor4i(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glColor4i "void glColor4i(GLint red, GLint green, GLint blue, GLint alpha)"
XEN_ASSERT_TYPE(XEN_GLint_P(red), red, 1, "glColor4i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(green), green, 2, "glColor4i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(blue), blue, 3, "glColor4i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(alpha), alpha, 4, "glColor4i", "GLint");
glColor4i(XEN_TO_C_GLint(red), XEN_TO_C_GLint(green), XEN_TO_C_GLint(blue), XEN_TO_C_GLint(alpha));
return(XEN_FALSE);
}
static XEN gxg_glColor4s(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glColor4s "void glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)"
XEN_ASSERT_TYPE(XEN_GLshort_P(red), red, 1, "glColor4s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(green), green, 2, "glColor4s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(blue), blue, 3, "glColor4s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(alpha), alpha, 4, "glColor4s", "GLshort");
glColor4s(XEN_TO_C_GLshort(red), XEN_TO_C_GLshort(green), XEN_TO_C_GLshort(blue), XEN_TO_C_GLshort(alpha));
return(XEN_FALSE);
}
static XEN gxg_glColor4ub(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glColor4ub "void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)"
XEN_ASSERT_TYPE(XEN_GLubyte_P(red), red, 1, "glColor4ub", "GLubyte");
XEN_ASSERT_TYPE(XEN_GLubyte_P(green), green, 2, "glColor4ub", "GLubyte");
XEN_ASSERT_TYPE(XEN_GLubyte_P(blue), blue, 3, "glColor4ub", "GLubyte");
XEN_ASSERT_TYPE(XEN_GLubyte_P(alpha), alpha, 4, "glColor4ub", "GLubyte");
glColor4ub(XEN_TO_C_GLubyte(red), XEN_TO_C_GLubyte(green), XEN_TO_C_GLubyte(blue), XEN_TO_C_GLubyte(alpha));
return(XEN_FALSE);
}
static XEN gxg_glColor4ui(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glColor4ui "void glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)"
XEN_ASSERT_TYPE(XEN_GLuint_P(red), red, 1, "glColor4ui", "GLuint");
XEN_ASSERT_TYPE(XEN_GLuint_P(green), green, 2, "glColor4ui", "GLuint");
XEN_ASSERT_TYPE(XEN_GLuint_P(blue), blue, 3, "glColor4ui", "GLuint");
XEN_ASSERT_TYPE(XEN_GLuint_P(alpha), alpha, 4, "glColor4ui", "GLuint");
glColor4ui(XEN_TO_C_GLuint(red), XEN_TO_C_GLuint(green), XEN_TO_C_GLuint(blue), XEN_TO_C_GLuint(alpha));
return(XEN_FALSE);
}
static XEN gxg_glColor4us(XEN red, XEN green, XEN blue, XEN alpha)
{
#define H_glColor4us "void glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)"
XEN_ASSERT_TYPE(XEN_GLushort_P(red), red, 1, "glColor4us", "GLushort");
XEN_ASSERT_TYPE(XEN_GLushort_P(green), green, 2, "glColor4us", "GLushort");
XEN_ASSERT_TYPE(XEN_GLushort_P(blue), blue, 3, "glColor4us", "GLushort");
XEN_ASSERT_TYPE(XEN_GLushort_P(alpha), alpha, 4, "glColor4us", "GLushort");
glColor4us(XEN_TO_C_GLushort(red), XEN_TO_C_GLushort(green), XEN_TO_C_GLushort(blue), XEN_TO_C_GLushort(alpha));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord1d(XEN s)
{
#define H_glTexCoord1d "void glTexCoord1d(GLdouble s)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(s), s, 1, "glTexCoord1d", "GLdouble");
glTexCoord1d(XEN_TO_C_GLdouble(s));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord1f(XEN s)
{
#define H_glTexCoord1f "void glTexCoord1f(GLfloat s)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(s), s, 1, "glTexCoord1f", "GLfloat");
glTexCoord1f(XEN_TO_C_GLfloat(s));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord1i(XEN s)
{
#define H_glTexCoord1i "void glTexCoord1i(GLint s)"
XEN_ASSERT_TYPE(XEN_GLint_P(s), s, 1, "glTexCoord1i", "GLint");
glTexCoord1i(XEN_TO_C_GLint(s));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord1s(XEN s)
{
#define H_glTexCoord1s "void glTexCoord1s(GLshort s)"
XEN_ASSERT_TYPE(XEN_GLshort_P(s), s, 1, "glTexCoord1s", "GLshort");
glTexCoord1s(XEN_TO_C_GLshort(s));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord2d(XEN s, XEN t)
{
#define H_glTexCoord2d "void glTexCoord2d(GLdouble s, GLdouble t)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(s), s, 1, "glTexCoord2d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(t), t, 2, "glTexCoord2d", "GLdouble");
glTexCoord2d(XEN_TO_C_GLdouble(s), XEN_TO_C_GLdouble(t));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord2f(XEN s, XEN t)
{
#define H_glTexCoord2f "void glTexCoord2f(GLfloat s, GLfloat t)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(s), s, 1, "glTexCoord2f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(t), t, 2, "glTexCoord2f", "GLfloat");
glTexCoord2f(XEN_TO_C_GLfloat(s), XEN_TO_C_GLfloat(t));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord2i(XEN s, XEN t)
{
#define H_glTexCoord2i "void glTexCoord2i(GLint s, GLint t)"
XEN_ASSERT_TYPE(XEN_GLint_P(s), s, 1, "glTexCoord2i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(t), t, 2, "glTexCoord2i", "GLint");
glTexCoord2i(XEN_TO_C_GLint(s), XEN_TO_C_GLint(t));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord2s(XEN s, XEN t)
{
#define H_glTexCoord2s "void glTexCoord2s(GLshort s, GLshort t)"
XEN_ASSERT_TYPE(XEN_GLshort_P(s), s, 1, "glTexCoord2s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(t), t, 2, "glTexCoord2s", "GLshort");
glTexCoord2s(XEN_TO_C_GLshort(s), XEN_TO_C_GLshort(t));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord3d(XEN s, XEN t, XEN r)
{
#define H_glTexCoord3d "void glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(s), s, 1, "glTexCoord3d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(t), t, 2, "glTexCoord3d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(r), r, 3, "glTexCoord3d", "GLdouble");
glTexCoord3d(XEN_TO_C_GLdouble(s), XEN_TO_C_GLdouble(t), XEN_TO_C_GLdouble(r));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord3f(XEN s, XEN t, XEN r)
{
#define H_glTexCoord3f "void glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(s), s, 1, "glTexCoord3f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(t), t, 2, "glTexCoord3f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(r), r, 3, "glTexCoord3f", "GLfloat");
glTexCoord3f(XEN_TO_C_GLfloat(s), XEN_TO_C_GLfloat(t), XEN_TO_C_GLfloat(r));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord3i(XEN s, XEN t, XEN r)
{
#define H_glTexCoord3i "void glTexCoord3i(GLint s, GLint t, GLint r)"
XEN_ASSERT_TYPE(XEN_GLint_P(s), s, 1, "glTexCoord3i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(t), t, 2, "glTexCoord3i", "GLint");
XEN_ASSERT_TYPE(XEN_GLint_P(r), r, 3, "glTexCoord3i", "GLint");
glTexCoord3i(XEN_TO_C_GLint(s), XEN_TO_C_GLint(t), XEN_TO_C_GLint(r));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord3s(XEN s, XEN t, XEN r)
{
#define H_glTexCoord3s "void glTexCoord3s(GLshort s, GLshort t, GLshort r)"
XEN_ASSERT_TYPE(XEN_GLshort_P(s), s, 1, "glTexCoord3s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(t), t, 2, "glTexCoord3s", "GLshort");
XEN_ASSERT_TYPE(XEN_GLshort_P(r), r, 3, "glTexCoord3s", "GLshort");
glTexCoord3s(XEN_TO_C_GLshort(s), XEN_TO_C_GLshort(t), XEN_TO_C_GLshort(r));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord4d(XEN s, XEN t, XEN r, XEN q)
{
#define H_glTexCoord4d "void glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)"
XEN_ASSERT_TYPE(XEN_GLdouble_P(s), s, 1, "glTexCoord4d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(t), t, 2, "glTexCoord4d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(r), r, 3, "glTexCoord4d", "GLdouble");
XEN_ASSERT_TYPE(XEN_GLdouble_P(q), q, 4, "glTexCoord4d", "GLdouble");
glTexCoord4d(XEN_TO_C_GLdouble(s), XEN_TO_C_GLdouble(t), XEN_TO_C_GLdouble(r), XEN_TO_C_GLdouble(q));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord4f(XEN s, XEN t, XEN r, XEN q)
{
#define H_glTexCoord4f "void glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)"
XEN_ASSERT_TYPE(XEN_GLfloat_P(s), s, 1, "glTexCoord4f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(t), t, 2, "glTexCoord4f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(r), r, 3, "glTexCoord4f", "GLfloat");
XEN_ASSERT_TYPE(XEN_GLfloat_P(q), q, 4, "glTexCoord4f", "GLfloat");
glTexCoord4f(XEN_TO_C_GLfloat(s), XEN_TO_C_GLfloat(t), XEN_TO_C_GLfloat(r), XEN_TO_C_GLfloat(q));
return(XEN_FALSE);
}
static XEN gxg_glTexCoord4i(XEN s, 
