/*
 * This file was generated automatically by ExtUtils::ParseXS version 3.34 from the
 * contents of pogl_gl_GetP_Pass.xs. Do not edit this file, edit pogl_gl_GetP_Pass.xs instead.
 *
 *    ANY CHANGES MADE HERE WILL BE LOST!
 *
 */

#line 1 "pogl_gl_GetP_Pass.xs"
/*  Last saved: Sun 06 Sep 2009 02:09:56 PM */

/*  Copyright (c) 1998 Kenneth Albanowski. All rights reserved.
 *  Copyright (c) 2007 Bob Free. All rights reserved.
 *  Copyright (c) 2009 Chris Marshall. All rights reserved.
 *  This program is free software; you can redistribute it and/or
 *  modify it under the same terms as Perl itself.
 */

/* OpenGL GLX bindings */
#define IN_POGL_GLX_XS

#include <stdio.h>

#include "pgopogl.h"

#ifdef HAVE_GL
#include "gl_util.h"

/* Note: this is caching procs once for all contexts */
/* !!! This should instead cache per context */
#if defined(_WIN32) || (defined(__CYGWIN__) && defined(HAVE_W32API))
#define loadProc(proc,name) \
{ \
  if (!proc) \
  { \
    proc = (void *)wglGetProcAddress(name); \
    if (!proc) croak(name " is not supported by this renderer"); \
  } \
}
#define testProc(proc,name) ((proc) ? 1 : !!(proc = (void *)wglGetProcAddress(name)))
#else /* not using WGL */
#define loadProc(proc,name)
#define testProc(proc,name) 1
#endif /* not defined _WIN32, __CYGWIN__, and HAVE_W32API */
#endif /* defined HAVE_GL */

#ifdef HAVE_GLX
#include "glx_util.h"
#endif /* defined HAVE_GLX */

#ifdef HAVE_GLU
#include "glu_util.h"
#endif /* defined HAVE_GLU */





#line 60 "pogl_gl_GetP_Pass.c"
#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#ifndef dVAR
#  define dVAR		dNOOP
#endif


/* This stuff is not part of the API! You have been warned. */
#ifndef PERL_VERSION_DECIMAL
#  define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
#endif
#ifndef PERL_DECIMAL_VERSION
#  define PERL_DECIMAL_VERSION \
	  PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
#endif
#ifndef PERL_VERSION_GE
#  define PERL_VERSION_GE(r,v,s) \
	  (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
#endif
#ifndef PERL_VERSION_LE
#  define PERL_VERSION_LE(r,v,s) \
	  (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
#endif

/* XS_INTERNAL is the explicit static-linkage variant of the default
 * XS macro.
 *
 * XS_EXTERNAL is the same as XS_INTERNAL except it does not include
 * "STATIC", ie. it exports XSUB symbols. You probably don't want that
 * for anything but the BOOT XSUB.
 *
 * See XSUB.h in core!
 */


/* TODO: This might be compatible further back than 5.10.0. */
#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
#  undef XS_EXTERNAL
#  undef XS_INTERNAL
#  if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
#    define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
#    define XS_INTERNAL(name) STATIC XSPROTO(name)
#  endif
#  if defined(__SYMBIAN32__)
#    define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
#    define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
#  endif
#  ifndef XS_EXTERNAL
#    if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
#      define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
#      define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
#    else
#      ifdef __cplusplus
#        define XS_EXTERNAL(name) extern "C" XSPROTO(name)
#        define XS_INTERNAL(name) static XSPROTO(name)
#      else
#        define XS_EXTERNAL(name) XSPROTO(name)
#        define XS_INTERNAL(name) STATIC XSPROTO(name)
#      endif
#    endif
#  endif
#endif

/* perl >= 5.10.0 && perl <= 5.15.1 */


/* The XS_EXTERNAL macro is used for functions that must not be static
 * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
 * macro defined, the best we can do is assume XS is the same.
 * Dito for XS_INTERNAL.
 */
#ifndef XS_EXTERNAL
#  define XS_EXTERNAL(name) XS(name)
#endif
#ifndef XS_INTERNAL
#  define XS_INTERNAL(name) XS(name)
#endif

/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
 * internal macro that we're free to redefine for varying linkage due
 * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
 * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
 */

#undef XS_EUPXS
#if defined(PERL_EUPXS_ALWAYS_EXPORT)
#  define XS_EUPXS(name) XS_EXTERNAL(name)
#else
   /* default to internal */
#  define XS_EUPXS(name) XS_INTERNAL(name)
#endif

#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)

/* prototype to pass -Wmissing-prototypes */
STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params);

STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params)
{
    const GV *const gv = CvGV(cv);

    PERL_ARGS_ASSERT_CROAK_XS_USAGE;

    if (gv) {
        const char *const gvname = GvNAME(gv);
        const HV *const stash = GvSTASH(gv);
        const char *const hvname = stash ? HvNAME(stash) : NULL;

        if (hvname)
	    Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params);
        else
	    Perl_croak_nocontext("Usage: %s(%s)", gvname, params);
    } else {
        /* Pants. I don't think that it should be possible to get here. */
	Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
    }
}
#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#define croak_xs_usage        S_croak_xs_usage

#endif

/* NOTE: the prototype of newXSproto() is different in versions of perls,
 * so we define a portable version of newXSproto()
 */
#ifdef newXS_flags
#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
#else
#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
#endif /* !defined(newXS_flags) */

#if PERL_VERSION_LE(5, 21, 5)
#  define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file)
#else
#  define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b)
#endif

#line 204 "pogl_gl_GetP_Pass.c"
#ifdef HAVE_GL
#define XSubPPtmpAAAA 1


XS_EUPXS(XS_OpenGL_glGetPixelMapfv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPixelMapfv_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "map, values");
    {
	GLenum	map = (int)SvIV(ST(0))
;
	void *	values = INT2PTR(void *,SvIV(ST(1)))
;
#line 66 "pogl_gl_GetP_Pass.xs"
	glGetPixelMapfv(map, values);
#line 222 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPixelMapuiv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPixelMapuiv_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "map, values");
    {
	GLenum	map = (int)SvIV(ST(0))
;
	void *	values = INT2PTR(void *,SvIV(ST(1)))
;
#line 75 "pogl_gl_GetP_Pass.xs"
	glGetPixelMapuiv(map, values);
#line 241 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPixelMapusv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPixelMapusv_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "map, values");
    {
	GLenum	map = (int)SvIV(ST(0))
;
	void *	values = INT2PTR(void *,SvIV(ST(1)))
;
#line 84 "pogl_gl_GetP_Pass.xs"
	glGetPixelMapusv(map, values);
#line 260 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPixelMapfv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPixelMapfv_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "map, values");
    {
	GLenum	map = (int)SvIV(ST(0))
;
	SV *	values = ST(1)
;
#line 93 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * values_s = EL(values, sizeof(GLfloat)* gl_pixelmap_size(map));
	glGetPixelMapfv(map, values_s);
	}
#line 282 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPixelMapuiv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPixelMapuiv_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "map, values");
    {
	GLenum	map = (int)SvIV(ST(0))
;
	SV *	values = ST(1)
;
#line 105 "pogl_gl_GetP_Pass.xs"
	{
	GLuint * values_s = EL(values, sizeof(GLuint)* gl_pixelmap_size(map));
	glGetPixelMapuiv(map, values_s);
	}
#line 304 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPixelMapusv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPixelMapusv_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "map, values");
    {
	GLenum	map = (int)SvIV(ST(0))
;
	SV *	values = ST(1)
;
#line 117 "pogl_gl_GetP_Pass.xs"
	{
	GLushort * values_s = EL(values, sizeof(GLushort)* gl_pixelmap_size(map));
	glGetPixelMapusv(map, values_s);
	}
#line 326 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPixelMapfv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPixelMapfv_p)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "map");
    {
	GLenum	map = (int)SvIV(ST(0))
;
#line 128 "pogl_gl_GetP_Pass.xs"
	{
		int count = gl_pixelmap_size(map);
		GLfloat * values;
		int i;

		values = malloc(sizeof(GLfloat) * count);

		glGetPixelMapfv(map, values);

		EXTEND(sp, count);

		for(i=0; i<count; i++)
			PUSHs(sv_2mortal(newSVnv(values[i])));

		free(values);
	}
#line 358 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPixelMapuiv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPixelMapuiv_p)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "map");
    {
	GLenum	map = (int)SvIV(ST(0))
;
#line 151 "pogl_gl_GetP_Pass.xs"
	{
		int count = gl_pixelmap_size(map);
		GLuint * values;
		int i;
		values = malloc(sizeof(GLuint) * count);
		glGetPixelMapuiv(map, values);
		EXTEND(sp, count);
		for(i=0; i<count; i++)
			PUSHs(sv_2mortal(newSViv(values[i])));
		free(values);
	}
#line 385 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPixelMapusv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPixelMapusv_p)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "map");
    {
	GLenum	map = (int)SvIV(ST(0))
;
#line 169 "pogl_gl_GetP_Pass.xs"
	{
		int count = gl_pixelmap_size(map);
		GLushort * values;
		int i;
		values = malloc(sizeof(GLushort) * count);
		glGetPixelMapusv(map, values);
		EXTEND(sp, count);
		for(i=0; i<count; i++)
			PUSHs(sv_2mortal(newSViv(values[i])));
		free(values);
	}
#line 412 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPolygonStipple_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPolygonStipple_c)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "mask");
    {
	void *	mask = INT2PTR(void *,SvIV(ST(0)))
;
#line 187 "pogl_gl_GetP_Pass.xs"
	glGetPolygonStipple(mask);
#line 429 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPolygonStipple_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPolygonStipple_s)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "mask");
    {
	SV *	mask = ST(0)
;
#line 195 "pogl_gl_GetP_Pass.xs"
	{
	GLubyte * ptr = ELI(mask, 32, 32, GL_COLOR_INDEX, GL_BITMAP, gl_pixelbuffer_unpack);
	glGetPolygonStipple(ptr);
	}
#line 449 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPolygonStipple_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPolygonStipple_p)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 205 "pogl_gl_GetP_Pass.xs"
	{
		void * ptr;
		glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
		glPixelStorei(GL_PACK_ROW_LENGTH, 0);
		glPixelStorei(GL_PACK_ALIGNMENT, 1);
		ptr = allocate_image_ST(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, 0);
		glGetPolygonStipple(ptr);
		sp = unpack_image_ST(sp, ptr, 32, 32, 1,
			GL_COLOR_INDEX, GL_BITMAP, 0);
		free(ptr);
		glPopClientAttrib();
	}
#line 477 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}

#ifdef GL_VERSION_1_1
#define XSubPPtmpAAAB 1


XS_EUPXS(XS_OpenGL_glGetPointerv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPointerv_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, params");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	void *	params = INT2PTR(void *,SvIV(ST(1)))
;
#line 227 "pogl_gl_GetP_Pass.xs"
	glGetPointerv(pname,&params);
#line 500 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPointerv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPointerv_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, params");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	SV *	params = ST(1)
;
#line 236 "pogl_gl_GetP_Pass.xs"
	{
		void ** params_s = EL(params, sizeof(void*));
		glGetPointerv(pname, params_s);
	}
#line 522 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetPointerv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetPointerv_p)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "pname");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	void *	RETVAL;
	dXSTARG;
#line 247 "pogl_gl_GetP_Pass.xs"
	glGetPointerv(pname, &RETVAL);
#line 541 "pogl_gl_GetP_Pass.c"
	XSprePUSH; PUSHi(PTR2IV(RETVAL));
    }
    XSRETURN(1);
}

#endif

XS_EUPXS(XS_OpenGL_glGetString); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetString)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "name");
    {
	GLenum	name = (int)SvIV(ST(0))
;
	SV *	RETVAL;
#line 259 "pogl_gl_GetP_Pass.xs"
	{
		char * c = (char*)glGetString(name);
		if (c)
			RETVAL = newSVpv(c, 0);
		else
			RETVAL = newSVsv(&PL_sv_undef);
	}
#line 567 "pogl_gl_GetP_Pass.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetTexEnvfv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexEnvfv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 277 "pogl_gl_GetP_Pass.xs"
	glGetTexEnvfv(target, pname, params);
#line 590 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexEnviv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexEnviv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 287 "pogl_gl_GetP_Pass.xs"
	glGetTexEnviv(target, pname, params);
#line 611 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexEnvfv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexEnvfv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 297 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * params_s = EL(params, sizeof(GLfloat) * gl_texenv_count(pname));
	glGetTexEnvfv(target, pname, params_s);
	}
#line 635 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexEnviv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexEnviv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 310 "pogl_gl_GetP_Pass.xs"
	{
	GLint * params_s = EL(params, sizeof(GLint) * gl_texenv_count(pname));
	glGetTexEnviv(target, pname, params_s);
	}
#line 659 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexEnvfv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexEnvfv_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, pname");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 322 "pogl_gl_GetP_Pass.xs"
	{
		GLfloat	ret[MAX_GL_TEXENV_COUNT];
		int n = gl_texenv_count(pname);
		int i;
		glGetTexEnvfv(target, pname, &ret[0]);
		EXTEND(sp, n);
		for(i=0;i<n;i++)
			PUSHs(sv_2mortal(newSVnv(ret[i])));
	}
#line 688 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetTexEnviv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexEnviv_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, pname");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 339 "pogl_gl_GetP_Pass.xs"
	{
		GLint	ret[MAX_GL_TEXENV_COUNT];
		int n = gl_texenv_count(pname);
		int i;
		glGetTexEnviv(target, pname, &ret[0]);
		EXTEND(sp, n);
		for(i=0;i<n;i++)
			PUSHs(sv_2mortal(newSViv(ret[i])));
	}
#line 718 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetTexGenfv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexGenfv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "coord, pname, params");
    {
	GLenum	coord = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 357 "pogl_gl_GetP_Pass.xs"
	glGetTexGenfv(coord, pname, params);
#line 740 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexGendv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexGendv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "coord, pname, params");
    {
	GLenum	coord = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 367 "pogl_gl_GetP_Pass.xs"
	glGetTexGendv(coord, pname, params);
#line 761 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexGeniv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexGeniv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "coord, pname, params");
    {
	GLenum	coord = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 377 "pogl_gl_GetP_Pass.xs"
	glGetTexGeniv(coord, pname, params);
#line 782 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexGendv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexGendv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "coord, pname, params");
    {
	GLenum	coord = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 387 "pogl_gl_GetP_Pass.xs"
	{
	GLdouble * params_s = EL(params, sizeof(GLdouble)*gl_texgen_count(pname));
	glGetTexGendv(coord, pname, params_s);
	}
#line 806 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexGenfv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexGenfv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "coord, pname, params");
    {
	GLenum	coord = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 400 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * params_s = EL(params, sizeof(GLfloat)*gl_texgen_count(pname));
	glGetTexGenfv(coord, pname, params_s);
	}
#line 830 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexGeniv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexGeniv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "coord, pname, params");
    {
	GLenum	coord = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 413 "pogl_gl_GetP_Pass.xs"
	{
	GLint * params_s = EL(params, sizeof(GLint)*gl_texgen_count(pname));
	glGetTexGeniv(coord, pname, params_s);
	}
#line 854 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexGenfv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexGenfv_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "coord, pname");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	coord = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 425 "pogl_gl_GetP_Pass.xs"
	{
		GLfloat	ret[MAX_GL_TEXGEN_COUNT];
		int n = gl_texgen_count(pname);
		int i;
		glGetTexGenfv(coord, pname, &ret[0]);
		EXTEND(sp, n);
		for(i=0;i<n;i++)
			PUSHs(sv_2mortal(newSVnv(ret[i])));
	}
#line 883 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetTexGendv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexGendv_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "coord, pname");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	coord = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 442 "pogl_gl_GetP_Pass.xs"
	{
		GLdouble	ret[MAX_GL_TEXGEN_COUNT];
		int n = gl_texgen_count(pname);
		int i;
		glGetTexGendv(coord, pname, &ret[0]);
		EXTEND(sp, n);
		for(i=0;i<n;i++)
			PUSHs(sv_2mortal(newSVnv(ret[i])));
	}
#line 913 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetTexGeniv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexGeniv_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "coord, pname");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	coord = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 459 "pogl_gl_GetP_Pass.xs"
	{
		GLint	ret[MAX_GL_TEXGEN_COUNT];
		int n = gl_texgen_count(pname);
		int i;
		glGetTexGeniv(coord, pname, &ret[0]);
		EXTEND(sp, n);
		for(i=0;i<n;i++)
			PUSHs(sv_2mortal(newSViv(ret[i])));
	}
#line 943 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetTexImage_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexImage_c)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "target, level, format, type, pixels");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	level = (int)SvIV(ST(1))
;
	GLenum	format = (int)SvIV(ST(2))
;
	GLenum	type = (int)SvIV(ST(3))
;
	void *	pixels = INT2PTR(void *,SvIV(ST(4)))
;
#line 479 "pogl_gl_GetP_Pass.xs"
	glGetTexImage(target, level, format, type, pixels);
#line 969 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexImage_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexImage_s)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "target, level, format, type, pixels");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	level = (int)SvIV(ST(1))
;
	GLenum	format = (int)SvIV(ST(2))
;
	GLenum	type = (int)SvIV(ST(3))
;
	SV *	pixels = ST(4)
;
#line 491 "pogl_gl_GetP_Pass.xs"
	{
		GLint width, height;
		GLvoid * ptr;

		glGetTexLevelParameteriv(target, level,
			GL_TEXTURE_WIDTH, &width);
		glGetTexLevelParameteriv(target, level,
			GL_TEXTURE_HEIGHT, &height);

		ptr = ELI(pixels, width, height, format, type,
			gl_pixelbuffer_unpack);
		glGetTexImage(target, level, format, type, pixels);
	}
#line 1006 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexImage_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexImage_p)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, level, format, type");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	level = (int)SvIV(ST(1))
;
	GLenum	format = (int)SvIV(ST(2))
;
	GLenum	type = (int)SvIV(ST(3))
;
#line 514 "pogl_gl_GetP_Pass.xs"
	{
		GLint width, height;
		GLvoid * ptr;

		glGetTexLevelParameteriv(target, level,
			GL_TEXTURE_WIDTH, &width);
		glGetTexLevelParameteriv(target, level,
			GL_TEXTURE_HEIGHT, &height);

		glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
		glPixelStorei(GL_PACK_ROW_LENGTH, 0);
		glPixelStorei(GL_PACK_ALIGNMENT, 1);

		ptr = allocate_image_ST(width, height, 1, format, type, 0);
		glGetTexImage(target, level, format, type, ptr);
		sp = unpack_image_ST(sp, ptr, width, height, 1, format, type, 0);

		free(ptr);
		glPopClientAttrib();
	}
#line 1050 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetTexLevelParameterfv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexLevelParameterfv_c)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, level, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	level = (int)SvIV(ST(1))
;
	GLenum	pname = (int)SvIV(ST(2))
;
	void *	params = INT2PTR(void *,SvIV(ST(3)))
;
#line 544 "pogl_gl_GetP_Pass.xs"
	glGetTexLevelParameterfv(target, level, pname, params);
#line 1074 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexLevelParameteriv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexLevelParameteriv_c)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, level, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	level = (int)SvIV(ST(1))
;
	GLenum	pname = (int)SvIV(ST(2))
;
	void *	params = INT2PTR(void *,SvIV(ST(3)))
;
#line 555 "pogl_gl_GetP_Pass.xs"
	glGetTexLevelParameteriv(target, level, pname, params);
#line 1097 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexLevelParameterfv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexLevelParameterfv_s)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, level, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	level = (int)SvIV(ST(1))
;
	GLenum	pname = (int)SvIV(ST(2))
;
	SV *	params = ST(3)
;
#line 566 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * params_s = EL(params, sizeof(GLfloat)*1);
	glGetTexLevelParameterfv(target, level, pname, params_s);
	}
#line 1123 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexLevelParameteriv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexLevelParameteriv_s)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, level, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	level = (int)SvIV(ST(1))
;
	GLenum	pname = (int)SvIV(ST(2))
;
	SV *	params = ST(3)
;
#line 580 "pogl_gl_GetP_Pass.xs"
	{
	GLint * params_s = EL(params, sizeof(GLint)*1);
	glGetTexLevelParameteriv(target, level, pname, params_s);
	}
#line 1149 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexLevelParameterfv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexLevelParameterfv_p)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, level, pname");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	level = (int)SvIV(ST(1))
;
	GLenum	pname = (int)SvIV(ST(2))
;
#line 593 "pogl_gl_GetP_Pass.xs"
	{
		GLfloat	ret;
		glGetTexLevelParameterfv(target, level, pname, &ret);
		PUSHs(sv_2mortal(newSVnv(ret)));
	}
#line 1176 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetTexLevelParameteriv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexLevelParameteriv_p)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, level, pname");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	level = (int)SvIV(ST(1))
;
	GLenum	pname = (int)SvIV(ST(2))
;
#line 607 "pogl_gl_GetP_Pass.xs"
	{
		GLint	ret;
		glGetTexLevelParameteriv(target, level, pname, &ret);
		PUSHs(sv_2mortal(newSViv(ret)));
	}
#line 1204 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetTexParameterfv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexParameterfv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 621 "pogl_gl_GetP_Pass.xs"
	glGetTexParameterfv(target, pname, params);
#line 1226 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexParameteriv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexParameteriv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 631 "pogl_gl_GetP_Pass.xs"
	glGetTexParameteriv(target, pname, params);
#line 1247 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexParameterfv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexParameterfv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 641 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * params_s = EL(params,
		sizeof(GLfloat)*gl_texparameter_count(pname));
	glGetTexParameterfv(target, pname, params_s);
	}
#line 1272 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexParameteriv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexParameteriv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 655 "pogl_gl_GetP_Pass.xs"
	{
	GLint * params_s = EL(params,
		sizeof(GLint)*gl_texparameter_count(pname));
	glGetTexParameteriv(target, pname, params_s);
	}
#line 1297 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetTexParameterfv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexParameterfv_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, pname");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 668 "pogl_gl_GetP_Pass.xs"
	{
		GLfloat	ret[MAX_GL_TEXPARAMETER_COUNT];
		int n = gl_texparameter_count(pname);
		int i;
		glGetTexParameterfv(target, pname, &ret[0]);
		EXTEND(sp, n);
		for(i=0;i<n;i++)
			PUSHs(sv_2mortal(newSVnv(ret[i])));
	}
#line 1326 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetTexParameteriv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetTexParameteriv_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, pname");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 685 "pogl_gl_GetP_Pass.xs"
	{
		GLint	ret[MAX_GL_TEXPARAMETER_COUNT];
		int n = gl_texparameter_count(pname);
		int i;
		glGetTexParameteriv(target, pname, &ret[0]);
		EXTEND(sp, n);
		for(i=0;i<n;i++)
			PUSHs(sv_2mortal(newSViv(ret[i])));
	}
#line 1356 "pogl_gl_GetP_Pass.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glHint); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glHint)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, mode");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	mode = (int)SvIV(ST(1))
;

	glHint(target, mode);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glIndexd); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glIndexd)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "c");
    {
	GLdouble	c = (double)SvNV(ST(0))
;

	glIndexd(c);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glIndexi); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glIndexi)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "c");
    {
	GLint	c = (int)SvIV(ST(0))
;

	glIndexi(c);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glIndexMask); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glIndexMask)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "mask");
    {
	GLuint	mask = (unsigned int)SvUV(ST(0))
;

	glIndexMask(mask);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glInitNames); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glInitNames)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {

	glInitNames();
    }
    XSRETURN_EMPTY;
}

#ifdef GL_VERSION_1_1
#define XSubPPtmpAAAC 1


XS_EUPXS(XS_OpenGL_glInterleavedArrays_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glInterleavedArrays_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "format, stride, pointer");
    {
	GLenum	format = (int)SvIV(ST(0))
;
	GLsizei	stride = (int)SvIV(ST(1))
;
	void *	pointer = INT2PTR(void *,SvIV(ST(2)))
;
#line 736 "pogl_gl_GetP_Pass.xs"
	glInterleavedArrays(format, stride, pointer);
#line 1461 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}

#endif

XS_EUPXS(XS_OpenGL_glIsEnabled); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glIsEnabled)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "cap");
    {
	GLenum	cap = (int)SvIV(ST(0))
;
	GLboolean	RETVAL;

	RETVAL = glIsEnabled(cap);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glIsList); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glIsList)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "list");
    {
	GLuint	list = (unsigned int)SvUV(ST(0))
;
	GLboolean	RETVAL;

	RETVAL = glIsList(list);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#ifdef GL_VERSION_1_1
#define XSubPPtmpAAAD 1


XS_EUPXS(XS_OpenGL_glIsTexture); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glIsTexture)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "list");
    {
	GLuint	list = (unsigned int)SvUV(ST(0))
;
	GLboolean	RETVAL;

	RETVAL = glIsTexture(list);
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#endif

XS_EUPXS(XS_OpenGL_glLightf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightf)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "light, pname, param");
    {
	GLenum	light = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	GLfloat	param = (float)SvNV(ST(2))
;

	glLightf(light, pname, param);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLighti); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLighti)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "light, pname, param");
    {
	GLenum	light = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	GLint	param = (int)SvIV(ST(2))
;

	glLighti(light, pname, param);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightfv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightfv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "light, pname, params");
    {
	GLenum	light = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 787 "pogl_gl_GetP_Pass.xs"
	glLightfv(light, pname, params);
#line 1581 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightiv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightiv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "light, pname, params");
    {
	GLenum	light = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 797 "pogl_gl_GetP_Pass.xs"
	glLightiv(light, pname, params);
#line 1602 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightfv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightfv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "light, pname, params");
    {
	GLenum	light = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 807 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * params_s = EL(params, sizeof(GLfloat)*gl_light_count(pname));
	glLightfv(light, pname, params_s);
	}
#line 1626 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightiv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightiv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "light, pname, params");
    {
	GLenum	light = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 820 "pogl_gl_GetP_Pass.xs"
	{
	GLint * params_s = EL(params, sizeof(GLint)*gl_light_count(pname));
	glLightiv(light, pname, params_s);
	}
#line 1650 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightfv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightfv_p)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "light, pname, ...");
    {
	GLenum	light = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 832 "pogl_gl_GetP_Pass.xs"
	{
		GLfloat p[MAX_GL_LIGHT_COUNT];
		int i;
		if ((items-2) != gl_light_count(pname))
			croak("Incorrect number of arguments");
		for(i=2;i<items;i++)
			p[i-2] = (GLfloat)SvNV(ST(i));
		glLightfv(light, pname, &p[0]);
	}
#line 1677 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightiv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightiv_p)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "light, pname, ...");
    {
	GLenum	light = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 849 "pogl_gl_GetP_Pass.xs"
	{
		GLint p[MAX_GL_LIGHT_COUNT];
		int i;
		if ((items-2) != gl_light_count(pname))
			croak("Incorrect number of arguments");
		for(i=2;i<items;i++)
			p[i-2] = SvIV(ST(i));
		glLightiv(light, pname, &p[0]);
	}
#line 1704 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightModelf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightModelf)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, param");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	GLfloat	param = (float)SvNV(ST(1))
;

	glLightModelf(pname, param);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightModeli); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightModeli)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, param");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	GLint	param = (int)SvIV(ST(1))
;

	glLightModeli(pname, param);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightModeliv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightModeliv_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, params");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	void *	params = INT2PTR(void *,SvIV(ST(1)))
;
#line 880 "pogl_gl_GetP_Pass.xs"
	glLightModeliv(pname, params);
#line 1759 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightModelfv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightModelfv_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, params");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	void *	params = INT2PTR(void *,SvIV(ST(1)))
;
#line 889 "pogl_gl_GetP_Pass.xs"
	glLightModelfv(pname, params);
#line 1778 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightModeliv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightModeliv_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, params");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	SV *	params = ST(1)
;
#line 898 "pogl_gl_GetP_Pass.xs"
	{
	GLint * params_s = EL(params, sizeof(GLint)*gl_lightmodel_count(pname));
	glLightModeliv(pname, params_s);
	}
#line 1800 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightModelfv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightModelfv_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, params");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	SV *	params = ST(1)
;
#line 910 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * params_s = EL(params,
		sizeof(GLfloat)*gl_lightmodel_count(pname));
	glLightModelfv(pname, params_s);
	}
#line 1823 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightModelfv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightModelfv_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "pname, ...");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
#line 922 "pogl_gl_GetP_Pass.xs"
	{
		GLfloat p[MAX_GL_LIGHTMODEL_COUNT];
		int i;
		if ((items-1) != gl_lightmodel_count(pname))
			croak("Incorrect number of arguments");
		for(i=1;i<items;i++)
			p[i-1] = (GLfloat)SvNV(ST(i));
		glLightModelfv(pname, &p[0]);
	}
#line 1848 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLightModeliv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLightModeliv_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "pname, ...");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
#line 938 "pogl_gl_GetP_Pass.xs"
	{
		GLint p[MAX_GL_LIGHTMODEL_COUNT];
		int i;
		if ((items-1) != gl_lightmodel_count(pname))
			croak("Incorrect number of arguments");
		for(i=1;i<items;i++)
			p[i-1] = SvIV(ST(i));
		glLightModeliv(pname, &p[0]);
	}
#line 1873 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLineStipple); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLineStipple)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "factor, pattern");
    {
	GLint	factor = (int)SvIV(ST(0))
;
	GLushort	pattern = (unsigned short)SvUV(ST(1))
;

	glLineStipple(factor, pattern);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLineWidth); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLineWidth)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "width");
    {
	GLfloat	width = (float)SvNV(ST(0))
;

	glLineWidth(width);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glListBase); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glListBase)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "base");
    {
	GLuint	base = (unsigned int)SvUV(ST(0))
;

	glListBase(base);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLoadIdentity); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLoadIdentity)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {

	glLoadIdentity();
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLoadMatrixf_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLoadMatrixf_c)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "m");
    {
	void *	m = INT2PTR(void *,SvIV(ST(0)))
;
#line 978 "pogl_gl_GetP_Pass.xs"
	glLoadMatrixf(m);
#line 1954 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLoadMatrixd_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLoadMatrixd_c)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "m");
    {
	void *	m = INT2PTR(void *,SvIV(ST(0)))
;
#line 986 "pogl_gl_GetP_Pass.xs"
	glLoadMatrixd(m);
#line 1971 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLoadMatrixf_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLoadMatrixf_s)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "m");
    {
	SV *	m = ST(0)
;
#line 994 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * m_s = EL(m, sizeof(GLfloat)*16);
	glLoadMatrixf(m_s);
	}
#line 1991 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLoadMatrixd_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLoadMatrixd_s)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "m");
    {
	SV *	m = ST(0)
;
#line 1005 "pogl_gl_GetP_Pass.xs"
	{
	GLdouble * m_s = EL(m, sizeof(GLdouble)*16);
	glLoadMatrixd(m_s);
	}
#line 2011 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLoadMatrixd_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLoadMatrixd_p)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
#line 1015 "pogl_gl_GetP_Pass.xs"
	{
		GLdouble m[16];
		int i;
		if (items != 16)
			croak("Incorrect number of arguments");
		for (i=0;i<16;i++)
			m[i] = SvNV(ST(i));
		glLoadMatrixd(&m[0]);
	}
#line 2033 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLoadMatrixf_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLoadMatrixf_p)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
#line 1030 "pogl_gl_GetP_Pass.xs"
	{
		GLfloat m[16];
		int i;
		if (items != 16)
			croak("Incorrect number of arguments");
		for (i=0;i<16;i++)
			m[i] = (GLfloat)SvNV(ST(i));
		glLoadMatrixf(&m[0]);
	}
#line 2055 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLoadName); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLoadName)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "name");
    {
	GLuint	name = (unsigned int)SvUV(ST(0))
;

	glLoadName(name);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLogicOp); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLogicOp)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "opcode");
    {
	GLenum	opcode = (int)SvIV(ST(0))
;

	glLogicOp(opcode);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap1d_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap1d_c)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "target, u1, u2, stride, order, points");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLdouble	u1 = (double)SvNV(ST(1))
;
	GLdouble	u2 = (double)SvNV(ST(2))
;
	GLint	stride = (int)SvIV(ST(3))
;
	GLint	order = (int)SvIV(ST(4))
;
	void *	points = INT2PTR(void *,SvIV(ST(5)))
;
#line 1063 "pogl_gl_GetP_Pass.xs"
	glMap1d(target, u1, u2, stride, order, points);
#line 2114 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap1f_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap1f_c)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "target, u1, u2, stride, order, points");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLfloat	u1 = (float)SvNV(ST(1))
;
	GLfloat	u2 = (float)SvNV(ST(2))
;
	GLint	stride = (int)SvIV(ST(3))
;
	GLint	order = (int)SvIV(ST(4))
;
	void *	points = INT2PTR(void *,SvIV(ST(5)))
;
#line 1076 "pogl_gl_GetP_Pass.xs"
	glMap1f(target, u1, u2, stride, order, points);
#line 2141 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap1d_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap1d_s)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "target, u1, u2, stride, order, points");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLdouble	u1 = (double)SvNV(ST(1))
;
	GLdouble	u2 = (double)SvNV(ST(2))
;
	GLint	stride = (int)SvIV(ST(3))
;
	GLint	order = (int)SvIV(ST(4))
;
	SV *	points = ST(5)
;
#line 1089 "pogl_gl_GetP_Pass.xs"
	{
	GLdouble * points_s = EL(points, 0 /*FIXME*/);
	glMap1d(target, u1, u2, stride, order, points_s);
	}
#line 2171 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap1f_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap1f_s)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "target, u1, u2, stride, order, points");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLfloat	u1 = (float)SvNV(ST(1))
;
	GLfloat	u2 = (float)SvNV(ST(2))
;
	GLint	stride = (int)SvIV(ST(3))
;
	GLint	order = (int)SvIV(ST(4))
;
	SV *	points = ST(5)
;
#line 1105 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * points_s = EL(points, 0 /*FIXME*/);
	glMap1f(target, u1, u2, stride, order, points_s);
	}
#line 2201 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap1d_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap1d_p)
{
    dVAR; dXSARGS;
    if (items < 3)
       croak_xs_usage(cv,  "target, u1, u2, ...");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLdouble	u1 = (double)SvNV(ST(1))
;
	GLdouble	u2 = (double)SvNV(ST(2))
;
#line 1119 "pogl_gl_GetP_Pass.xs"
	{
		int count = items-3;
		GLint order = (items - 3) / gl_map_count(target, GL_COEFF);
		GLdouble * points = malloc(sizeof(GLdouble) * (count+1));
		int i;
		for (i=0;i<count;i++)
			points[i] = SvNV(ST(i+3));
		glMap1d(target, u1, u2, 0, order, points);
		free(points);
	}
#line 2231 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap1f_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap1f_p)
{
    dVAR; dXSARGS;
    if (items < 3)
       croak_xs_usage(cv,  "target, u1, u2, ...");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLfloat	u1 = (float)SvNV(ST(1))
;
	GLfloat	u2 = (float)SvNV(ST(2))
;
#line 1139 "pogl_gl_GetP_Pass.xs"
	{
		int count = items-3;
		GLint order = (items - 3) / gl_map_count(target, GL_COEFF);
		GLfloat * points = malloc(sizeof(GLfloat) * (count+1));
		int i;
		for (i=0;i<count;i++)
			points[i] = (GLfloat)SvNV(ST(i+3));
		glMap1f(target, u1, u2, 0, order, points);
		free(points);
	}
#line 2261 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap2d_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap2d_c)
{
    dVAR; dXSARGS;
    if (items != 10)
       croak_xs_usage(cv,  "target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLdouble	u1 = (double)SvNV(ST(1))
;
	GLdouble	u2 = (double)SvNV(ST(2))
;
	GLint	ustride = (int)SvIV(ST(3))
;
	GLint	uorder = (int)SvIV(ST(4))
;
	GLdouble	v1 = (double)SvNV(ST(5))
;
	GLdouble	v2 = (double)SvNV(ST(6))
;
	GLint	vstride = (int)SvIV(ST(7))
;
	GLint	vorder = (int)SvIV(ST(8))
;
	void *	points = INT2PTR(void *,SvIV(ST(9)))
;
#line 1165 "pogl_gl_GetP_Pass.xs"
	glMap2d(target, u1, u2, ustride, uorder, v1, v2,
		vstride, vorder, points);
#line 2297 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap2f_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap2f_c)
{
    dVAR; dXSARGS;
    if (items != 10)
       croak_xs_usage(cv,  "target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLfloat	u1 = (float)SvNV(ST(1))
;
	GLfloat	u2 = (float)SvNV(ST(2))
;
	GLint	ustride = (int)SvIV(ST(3))
;
	GLint	uorder = (int)SvIV(ST(4))
;
	GLfloat	v1 = (float)SvNV(ST(5))
;
	GLfloat	v2 = (float)SvNV(ST(6))
;
	GLint	vstride = (int)SvIV(ST(7))
;
	GLint	vorder = (int)SvIV(ST(8))
;
	void *	points = INT2PTR(void *,SvIV(ST(9)))
;
#line 1183 "pogl_gl_GetP_Pass.xs"
	glMap2f(target, u1, u2, ustride, uorder, v1, v2,
		vstride, vorder, points);
#line 2333 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap2d_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap2d_s)
{
    dVAR; dXSARGS;
    if (items != 10)
       croak_xs_usage(cv,  "target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLdouble	u1 = (double)SvNV(ST(1))
;
	GLdouble	u2 = (double)SvNV(ST(2))
;
	GLint	ustride = (int)SvIV(ST(3))
;
	GLint	uorder = (int)SvIV(ST(4))
;
	GLdouble	v1 = (double)SvNV(ST(5))
;
	GLdouble	v2 = (double)SvNV(ST(6))
;
	GLint	vstride = (int)SvIV(ST(7))
;
	GLint	vorder = (int)SvIV(ST(8))
;
	SV *	points = ST(9)
;
#line 1201 "pogl_gl_GetP_Pass.xs"
	{
	GLdouble * points_s = EL(points, 0 /*FIXME*/);
	glMap2d(target, u1, u2, ustride, uorder, v1, v2,
		vstride, vorder, points_s);
	}
#line 2372 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap2f_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap2f_s)
{
    dVAR; dXSARGS;
    if (items != 10)
       croak_xs_usage(cv,  "target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLfloat	u1 = (float)SvNV(ST(1))
;
	GLfloat	u2 = (float)SvNV(ST(2))
;
	GLint	ustride = (int)SvIV(ST(3))
;
	GLint	uorder = (int)SvIV(ST(4))
;
	GLfloat	v1 = (float)SvNV(ST(5))
;
	GLfloat	v2 = (float)SvNV(ST(6))
;
	GLint	vstride = (int)SvIV(ST(7))
;
	GLint	vorder = (int)SvIV(ST(8))
;
	SV *	points = ST(9)
;
#line 1222 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * points_s = EL(points, 0 /*FIXME*/);
	glMap2f(target, u1, u2, ustride, uorder, v1, v2,
		vstride, vorder, points_s);
	}
#line 2411 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap2d_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap2d_p)
{
    dVAR; dXSARGS;
    if (items < 6)
       croak_xs_usage(cv,  "target, u1, u2, uorder, v1, v2, ...");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLdouble	u1 = (double)SvNV(ST(1))
;
	GLdouble	u2 = (double)SvNV(ST(2))
;
	GLint	uorder = (int)SvIV(ST(3))
;
	GLdouble	v1 = (double)SvNV(ST(4))
;
	GLdouble	v2 = (double)SvNV(ST(5))
;
#line 1240 "pogl_gl_GetP_Pass.xs"
	{
		int count = items-6;
		GLint vorder = (count / uorder) / gl_map_count(target, GL_COEFF);
		GLdouble * points = malloc(sizeof(GLdouble) * (count+1));
		int i;
		for (i=0;i<count;i++)
			points[i] = SvNV(ST(i+6));
		glMap2d(target, u1, u2, 0, uorder, v1, v2, 0, vorder, points);
		free(points);
	}
#line 2447 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMap2f_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMap2f_p)
{
    dVAR; dXSARGS;
    if (items < 6)
       croak_xs_usage(cv,  "target, u1, u2, uorder, v1, v2, ...");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLfloat	u1 = (float)SvNV(ST(1))
;
	GLfloat	u2 = (float)SvNV(ST(2))
;
	GLint	uorder = (int)SvIV(ST(3))
;
	GLfloat	v1 = (float)SvNV(ST(4))
;
	GLfloat	v2 = (float)SvNV(ST(5))
;
#line 1263 "pogl_gl_GetP_Pass.xs"
	{
		int count = items-6;
		GLint vorder = (count / uorder) / gl_map_count(target, GL_COEFF);
		GLfloat * points = malloc(sizeof(GLfloat) * (count+1));
		int i;
		for (i=0;i<count;i++)
			points[i] = (GLfloat)SvNV(ST(i+6));
		glMap2f(target, u1, u2, 0, uorder, v1, v2, 0, vorder, points);
		free(points);
	}
#line 2483 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMapGrid1d); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMapGrid1d)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "un, u1, u2");
    {
	GLint	un = (int)SvIV(ST(0))
;
	GLdouble	u1 = (double)SvNV(ST(1))
;
	GLdouble	u2 = (double)SvNV(ST(2))
;

	glMapGrid1d(un, u1, u2);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMapGrid1f); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMapGrid1f)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "un, u1, u2");
    {
	GLint	un = (int)SvIV(ST(0))
;
	GLfloat	u1 = (float)SvNV(ST(1))
;
	GLfloat	u2 = (float)SvNV(ST(2))
;

	glMapGrid1f(un, u1, u2);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMapGrid2d); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMapGrid2d)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "un, u1, u2, vn, v1, v2");
    {
	GLint	un = (int)SvIV(ST(0))
;
	GLdouble	u1 = (double)SvNV(ST(1))
;
	GLdouble	u2 = (double)SvNV(ST(2))
;
	GLint	vn = (int)SvIV(ST(3))
;
	GLdouble	v1 = (double)SvNV(ST(4))
;
	GLdouble	v2 = (double)SvNV(ST(5))
;

	glMapGrid2d(un, u1, u2, vn, v1, v2);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMapGrid2f); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMapGrid2f)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "un, u1, u2, vn, v1, v2");
    {
	GLint	un = (int)SvIV(ST(0))
;
	GLfloat	u1 = (float)SvNV(ST(1))
;
	GLfloat	u2 = (float)SvNV(ST(2))
;
	GLint	vn = (int)SvIV(ST(3))
;
	GLfloat	v1 = (float)SvNV(ST(4))
;
	GLfloat	v2 = (float)SvNV(ST(5))
;

	glMapGrid2f(un, u1, u2, vn, v1, v2);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMaterialf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMaterialf)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "face, pname, param");
    {
	GLenum	face = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	GLfloat	param = (float)SvNV(ST(2))
;

	glMaterialf(face, pname, param);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMateriali); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMateriali)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "face, pname, param");
    {
	GLenum	face = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	GLint	param = (int)SvIV(ST(2))
;

	glMateriali(face, pname, param);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMaterialfv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMaterialfv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "face, pname, param");
    {
	GLenum	face = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	param = INT2PTR(void *,SvIV(ST(2)))
;
#line 1336 "pogl_gl_GetP_Pass.xs"
	glMaterialfv(face, pname, param);
#line 2636 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMaterialiv_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMaterialiv_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "face, pname, param");
    {
	GLenum	face = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	param = INT2PTR(void *,SvIV(ST(2)))
;
#line 1346 "pogl_gl_GetP_Pass.xs"
	glMaterialiv(face, pname, param);
#line 2657 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMaterialfv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMaterialfv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "face, pname, param");
    {
	GLenum	face = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	param = ST(2)
;
#line 1356 "pogl_gl_GetP_Pass.xs"
	{
	GLfloat * param_s = EL(param, sizeof(GLfloat)*gl_material_count(pname));
	glMaterialfv(face, pname, param_s);
	}
#line 2681 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMaterialiv_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMaterialiv_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "face, pname, param");
    {
	GLenum	face = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	param = ST(2)
;
#line 1369 "pogl_gl_GetP_Pass.xs"
	{
	GLint * param_s = EL(param, sizeof(GLint)*gl_material_count(pname));
	glMaterialiv(face, pname, param_s);
	}
#line 2705 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMaterialfv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMaterialfv_p)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "face, pname, ...");
    {
	GLenum	face = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 1381 "pogl_gl_GetP_Pass.xs"
	{
		GLfloat p[MAX_GL_MATERIAL_COUNT];
		int i;
		if ((items-2) != gl_material_count(pname))
			croak("Incorrect number of arguments");
		for(i=2;i<items;i++)
			p[i-2] = (GLfloat)SvNV(ST(i));
		glMaterialfv(face, pname, &p[0]);
	}
#line 2732 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMaterialiv_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMaterialiv_p)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "face, pname, ...");
    {
	GLenum	face = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 1398 "pogl_gl_GetP_Pass.xs"
	{
		GLint p[MAX_GL_MATERIAL_COUNT];
		int i;
		if ((items-2) != gl_material_count(pname))
			croak("Incorrect number of arguments");
		for(i=2;i<items;i++)
			p[i-2] = SvIV(ST(i));
		glMaterialiv(face, pname, &p[0]);
	}
#line 2759 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMatrixMode); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMatrixMode)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "mode");
    {
	GLenum	mode = (int)SvIV(ST(0))
;

	glMatrixMode(mode);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultMatrixd_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultMatrixd_p)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
#line 1419 "pogl_gl_GetP_Pass.xs"
	{
		GLdouble m[16];
		int i;
		if (items != 16)
			croak("Incorrect number of arguments");
		for (i=0;i<16;i++)
			m[i] = SvNV(ST(i));
		glMultMatrixd(&m[0]);
	}
#line 2797 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultMatrixf_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultMatrixf_p)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
#line 1434 "pogl_gl_GetP_Pass.xs"
	{
		GLfloat m[16];
		int i;
		if (items != 16)
			croak("Incorrect number of arguments");
		for (i=0;i<16;i++)
			m[i] = (GLfloat)SvNV(ST(i));
		glMultMatrixf(&m[0]);
	}
#line 2819 "pogl_gl_GetP_Pass.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glNewList); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glNewList)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "list, mode");
    {
	GLuint	list = (unsigned int)SvUV(ST(0))
;
	GLenum	mode = (int)SvIV(ST(1))
;

	glNewList(list, mode);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glEndList); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glEndList)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {

	glEndList();
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glOrtho); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glOrtho)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "left, right, bottom, top, zNear, zFar");
    {
	GLdouble	left = (double)SvNV(ST(0))
;
	GLdouble	right = (double)SvNV(ST(1))
;
	GLdouble	bottom = (double)SvNV(ST(2))
;
	GLdouble	top = (double)SvNV(ST(3))
;
	GLdouble	zNear = (double)SvNV(ST(4))
;
	GLdouble	zFar = (double)SvNV(ST(5))
;

	glOrtho(left, right, bottom, top, zNear, zFar);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glPassThrough); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glPassThrough)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "token");
    {
	GLfloat	token = (float)SvNV(ST(0))
;

	glPassThrough(token);
    }
    XSRETURN_EMPTY;
}

#endif /* HAVE_GL */
#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_OpenGL__GL__GetPPass); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_OpenGL__GL__GetPPass)
{
#if PERL_VERSION_LE(5, 21, 5)
    dVAR; dXSARGS;
#else
    dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if (PERL_REVISION == 5 && PERL_VERSION < 9)
    char* file = __FILE__;
#else
    const char* file = __FILE__;
#endif

    PERL_UNUSED_VAR(file);

    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
#if PERL_VERSION_LE(5, 21, 5)
    XS_VERSION_BOOTCHECK;
#  ifdef XS_APIVERSION_BOOTCHECK
    XS_APIVERSION_BOOTCHECK;
#  endif
#endif

#if XSubPPtmpAAAA
        newXS_deffile("OpenGL::glGetPixelMapfv_c", XS_OpenGL_glGetPixelMapfv_c);
        newXS_deffile("OpenGL::glGetPixelMapuiv_c", XS_OpenGL_glGetPixelMapuiv_c);
        newXS_deffile("OpenGL::glGetPixelMapusv_c", XS_OpenGL_glGetPixelMapusv_c);
        newXS_deffile("OpenGL::glGetPixelMapfv_s", XS_OpenGL_glGetPixelMapfv_s);
        newXS_deffile("OpenGL::glGetPixelMapuiv_s", XS_OpenGL_glGetPixelMapuiv_s);
        newXS_deffile("OpenGL::glGetPixelMapusv_s", XS_OpenGL_glGetPixelMapusv_s);
        newXS_deffile("OpenGL::glGetPixelMapfv_p", XS_OpenGL_glGetPixelMapfv_p);
        newXS_deffile("OpenGL::glGetPixelMapuiv_p", XS_OpenGL_glGetPixelMapuiv_p);
        newXS_deffile("OpenGL::glGetPixelMapusv_p", XS_OpenGL_glGetPixelMapusv_p);
        newXS_deffile("OpenGL::glGetPolygonStipple_c", XS_OpenGL_glGetPolygonStipple_c);
        newXS_deffile("OpenGL::glGetPolygonStipple_s", XS_OpenGL_glGetPolygonStipple_s);
        newXS_deffile("OpenGL::glGetPolygonStipple_p", XS_OpenGL_glGetPolygonStipple_p);
#if XSubPPtmpAAAB
        newXS_deffile("OpenGL::glGetPointerv_c", XS_OpenGL_glGetPointerv_c);
        newXS_deffile("OpenGL::glGetPointerv_s", XS_OpenGL_glGetPointerv_s);
        newXS_deffile("OpenGL::glGetPointerv_p", XS_OpenGL_glGetPointerv_p);
#endif
        newXS_deffile("OpenGL::glGetString", XS_OpenGL_glGetString);
        newXS_deffile("OpenGL::glGetTexEnvfv_c", XS_OpenGL_glGetTexEnvfv_c);
        newXS_deffile("OpenGL::glGetTexEnviv_c", XS_OpenGL_glGetTexEnviv_c);
        newXS_deffile("OpenGL::glGetTexEnvfv_s", XS_OpenGL_glGetTexEnvfv_s);
        newXS_deffile("OpenGL::glGetTexEnviv_s", XS_OpenGL_glGetTexEnviv_s);
        newXS_deffile("OpenGL::glGetTexEnvfv_p", XS_OpenGL_glGetTexEnvfv_p);
        newXS_deffile("OpenGL::glGetTexEnviv_p", XS_OpenGL_glGetTexEnviv_p);
        newXS_deffile("OpenGL::glGetTexGenfv_c", XS_OpenGL_glGetTexGenfv_c);
        newXS_deffile("OpenGL::glGetTexGendv_c", XS_OpenGL_glGetTexGendv_c);
        newXS_deffile("OpenGL::glGetTexGeniv_c", XS_OpenGL_glGetTexGeniv_c);
        newXS_deffile("OpenGL::glGetTexGendv_s", XS_OpenGL_glGetTexGendv_s);
        newXS_deffile("OpenGL::glGetTexGenfv_s", XS_OpenGL_glGetTexGenfv_s);
        newXS_deffile("OpenGL::glGetTexGeniv_s", XS_OpenGL_glGetTexGeniv_s);
        newXS_deffile("OpenGL::glGetTexGenfv_p", XS_OpenGL_glGetTexGenfv_p);
        newXS_deffile("OpenGL::glGetTexGendv_p", XS_OpenGL_glGetTexGendv_p);
        newXS_deffile("OpenGL::glGetTexGeniv_p", XS_OpenGL_glGetTexGeniv_p);
        newXS_deffile("OpenGL::glGetTexImage_c", XS_OpenGL_glGetTexImage_c);
        newXS_deffile("OpenGL::glGetTexImage_s", XS_OpenGL_glGetTexImage_s);
        newXS_deffile("OpenGL::glGetTexImage_p", XS_OpenGL_glGetTexImage_p);
        newXS_deffile("OpenGL::glGetTexLevelParameterfv_c", XS_OpenGL_glGetTexLevelParameterfv_c);
        newXS_deffile("OpenGL::glGetTexLevelParameteriv_c", XS_OpenGL_glGetTexLevelParameteriv_c);
        newXS_deffile("OpenGL::glGetTexLevelParameterfv_s", XS_OpenGL_glGetTexLevelParameterfv_s);
        newXS_deffile("OpenGL::glGetTexLevelParameteriv_s", XS_OpenGL_glGetTexLevelParameteriv_s);
        newXS_deffile("OpenGL::glGetTexLevelParameterfv_p", XS_OpenGL_glGetTexLevelParameterfv_p);
        newXS_deffile("OpenGL::glGetTexLevelParameteriv_p", XS_OpenGL_glGetTexLevelParameteriv_p);
        newXS_deffile("OpenGL::glGetTexParameterfv_c", XS_OpenGL_glGetTexParameterfv_c);
        newXS_deffile("OpenGL::glGetTexParameteriv_c", XS_OpenGL_glGetTexParameteriv_c);
        newXS_deffile("OpenGL::glGetTexParameterfv_s", XS_OpenGL_glGetTexParameterfv_s);
        newXS_deffile("OpenGL::glGetTexParameteriv_s", XS_OpenGL_glGetTexParameteriv_s);
        newXS_deffile("OpenGL::glGetTexParameterfv_p", XS_OpenGL_glGetTexParameterfv_p);
        newXS_deffile("OpenGL::glGetTexParameteriv_p", XS_OpenGL_glGetTexParameteriv_p);
        newXS_deffile("OpenGL::glHint", XS_OpenGL_glHint);
        newXS_deffile("OpenGL::glIndexd", XS_OpenGL_glIndexd);
        newXS_deffile("OpenGL::glIndexi", XS_OpenGL_glIndexi);
        newXS_deffile("OpenGL::glIndexMask", XS_OpenGL_glIndexMask);
        newXS_deffile("OpenGL::glInitNames", XS_OpenGL_glInitNames);
#if XSubPPtmpAAAC
        newXS_deffile("OpenGL::glInterleavedArrays_c", XS_OpenGL_glInterleavedArrays_c);
#endif
        newXS_deffile("OpenGL::glIsEnabled", XS_OpenGL_glIsEnabled);
        newXS_deffile("OpenGL::glIsList", XS_OpenGL_glIsList);
#if XSubPPtmpAAAD
        newXS_deffile("OpenGL::glIsTexture", XS_OpenGL_glIsTexture);
#endif
        newXS_deffile("OpenGL::glLightf", XS_OpenGL_glLightf);
        newXS_deffile("OpenGL::glLighti", XS_OpenGL_glLighti);
        newXS_deffile("OpenGL::glLightfv_c", XS_OpenGL_glLightfv_c);
        newXS_deffile("OpenGL::glLightiv_c", XS_OpenGL_glLightiv_c);
        newXS_deffile("OpenGL::glLightfv_s", XS_OpenGL_glLightfv_s);
        newXS_deffile("OpenGL::glLightiv_s", XS_OpenGL_glLightiv_s);
        newXS_deffile("OpenGL::glLightfv_p", XS_OpenGL_glLightfv_p);
        newXS_deffile("OpenGL::glLightiv_p", XS_OpenGL_glLightiv_p);
        newXS_deffile("OpenGL::glLightModelf", XS_OpenGL_glLightModelf);
        newXS_deffile("OpenGL::glLightModeli", XS_OpenGL_glLightModeli);
        newXS_deffile("OpenGL::glLightModeliv_c", XS_OpenGL_glLightModeliv_c);
        newXS_deffile("OpenGL::glLightModelfv_c", XS_OpenGL_glLightModelfv_c);
        newXS_deffile("OpenGL::glLightModeliv_s", XS_OpenGL_glLightModeliv_s);
        newXS_deffile("OpenGL::glLightModelfv_s", XS_OpenGL_glLightModelfv_s);
        newXS_deffile("OpenGL::glLightModelfv_p", XS_OpenGL_glLightModelfv_p);
        newXS_deffile("OpenGL::glLightModeliv_p", XS_OpenGL_glLightModeliv_p);
        newXS_deffile("OpenGL::glLineStipple", XS_OpenGL_glLineStipple);
        newXS_deffile("OpenGL::glLineWidth", XS_OpenGL_glLineWidth);
        newXS_deffile("OpenGL::glListBase", XS_OpenGL_glListBase);
        newXS_deffile("OpenGL::glLoadIdentity", XS_OpenGL_glLoadIdentity);
        newXS_deffile("OpenGL::glLoadMatrixf_c", XS_OpenGL_glLoadMatrixf_c);
        newXS_deffile("OpenGL::glLoadMatrixd_c", XS_OpenGL_glLoadMatrixd_c);
        newXS_deffile("OpenGL::glLoadMatrixf_s", XS_OpenGL_glLoadMatrixf_s);
        newXS_deffile("OpenGL::glLoadMatrixd_s", XS_OpenGL_glLoadMatrixd_s);
        newXS_deffile("OpenGL::glLoadMatrixd_p", XS_OpenGL_glLoadMatrixd_p);
        newXS_deffile("OpenGL::glLoadMatrixf_p", XS_OpenGL_glLoadMatrixf_p);
        newXS_deffile("OpenGL::glLoadName", XS_OpenGL_glLoadName);
        newXS_deffile("OpenGL::glLogicOp", XS_OpenGL_glLogicOp);
        newXS_deffile("OpenGL::glMap1d_c", XS_OpenGL_glMap1d_c);
        newXS_deffile("OpenGL::glMap1f_c", XS_OpenGL_glMap1f_c);
        newXS_deffile("OpenGL::glMap1d_s", XS_OpenGL_glMap1d_s);
        newXS_deffile("OpenGL::glMap1f_s", XS_OpenGL_glMap1f_s);
        newXS_deffile("OpenGL::glMap1d_p", XS_OpenGL_glMap1d_p);
        newXS_deffile("OpenGL::glMap1f_p", XS_OpenGL_glMap1f_p);
        newXS_deffile("OpenGL::glMap2d_c", XS_OpenGL_glMap2d_c);
        newXS_deffile("OpenGL::glMap2f_c", XS_OpenGL_glMap2f_c);
        newXS_deffile("OpenGL::glMap2d_s", XS_OpenGL_glMap2d_s);
        newXS_deffile("OpenGL::glMap2f_s", XS_OpenGL_glMap2f_s);
        newXS_deffile("OpenGL::glMap2d_p", XS_OpenGL_glMap2d_p);
        newXS_deffile("OpenGL::glMap2f_p", XS_OpenGL_glMap2f_p);
        newXS_deffile("OpenGL::glMapGrid1d", XS_OpenGL_glMapGrid1d);
        newXS_deffile("OpenGL::glMapGrid1f", XS_OpenGL_glMapGrid1f);
        newXS_deffile("OpenGL::glMapGrid2d", XS_OpenGL_glMapGrid2d);
        newXS_deffile("OpenGL::glMapGrid2f", XS_OpenGL_glMapGrid2f);
        newXS_deffile("OpenGL::glMaterialf", XS_OpenGL_glMaterialf);
        newXS_deffile("OpenGL::glMateriali", XS_OpenGL_glMateriali);
        newXS_deffile("OpenGL::glMaterialfv_c", XS_OpenGL_glMaterialfv_c);
        newXS_deffile("OpenGL::glMaterialiv_c", XS_OpenGL_glMaterialiv_c);
        newXS_deffile("OpenGL::glMaterialfv_s", XS_OpenGL_glMaterialfv_s);
        newXS_deffile("OpenGL::glMaterialiv_s", XS_OpenGL_glMaterialiv_s);
        newXS_deffile("OpenGL::glMaterialfv_p", XS_OpenGL_glMaterialfv_p);
        newXS_deffile("OpenGL::glMaterialiv_p", XS_OpenGL_glMaterialiv_p);
        newXS_deffile("OpenGL::glMatrixMode", XS_OpenGL_glMatrixMode);
        newXS_deffile("OpenGL::glMultMatrixd_p", XS_OpenGL_glMultMatrixd_p);
        newXS_deffile("OpenGL::glMultMatrixf_p", XS_OpenGL_glMultMatrixf_p);
        newXS_deffile("OpenGL::glNewList", XS_OpenGL_glNewList);
        newXS_deffile("OpenGL::glEndList", XS_OpenGL_glEndList);
        newXS_deffile("OpenGL::glOrtho", XS_OpenGL_glOrtho);
        newXS_deffile("OpenGL::glPassThrough", XS_OpenGL_glPassThrough);
#endif

    /* Initialisation Section */

#if XSubPPtmpAAAA
#if XSubPPtmpAAAB
#endif
#if XSubPPtmpAAAC
#endif
#if XSubPPtmpAAAD
#endif
#endif
#line 3060 "pogl_gl_GetP_Pass.c"

    /* End of Initialisation Section */

#if PERL_VERSION_LE(5, 21, 5)
#  if PERL_VERSION_GE(5, 9, 0)
    if (PL_unitcheckav)
        call_list(PL_scopestack_ix, PL_unitcheckav);
#  endif
    XSRETURN_YES;
#else
    Perl_xs_boot_epilog(aTHX_ ax);
#endif
}

