src/SDL/OpenGL.c

   1 /*
   2  * This file was generated automatically by xsubpp version 1.9508 from the
   3  * contents of OpenGL.xs. Do not edit this file, edit OpenGL.xs instead.
   4  *
   5  *      ANY CHANGES MADE HERE WILL BE LOST!
   6  *
   7  */
   8
   9 #line 1 "OpenGL.xs"
  10 //
  11 // OpenGL.xs
  12 //
  13 // Copyright (C) 2005 David J. Goehrig <dgoehrig@cpan.org>
  14 //
  15 // ------------------------------------------------------------------------------
  16 //
  17 // This library is free software; you can redistribute it and/or
  18 // modify it under the terms of the GNU Lesser General Public
  19 // License as published by the Free Software Foundation; either
  20 // version 2.1 of the License, or (at your option) any later version.
  21 //
  22 // This library is distributed in the hope that it will be useful,
  23 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  25 // Lesser General Public License for more details.
  26 //
  27 // You should have received a copy of the GNU Lesser General Public
  28 // License along with this library; if not, write to the Free Software
  29 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  30 //
  31 // ------------------------------------------------------------------------------
  32 //
  33 // Please feel free to send questions, suggestions or improvements to:
  34 //
  35 //      David J. Goehrig
  36 //      dgoehrig@cpan.org
  37 //
  38
  39 #include "EXTERN.h"
  40 #include "perl.h"
  41 #include "XSUB.h"
  42
  43 #ifndef aTHX_
  44 #define aTHX_
  45 #endif
  46
  47 #include <SDL.h>
  48
  49 #include <gl.h>
  50 #include <glu.h>
  51
  52 #ifdef USE_THREADS
  53 #define HAVE_TLS_CONTEXT
  54 #endif
  55
  56 #ifndef GL_ALL_CLIENT_ATTRIB_BITS
  57 #define GL_ALL_CLIENT_ATTRIB_BITS 0xFFFFFFF
  58 #endif /* GL_ALL_CLIENT_BITS */
  59
  60 #include "../defines.h"
  61
  62 SV* sdl_perl_nurbs_error_hook;
  63 void
  64 sdl_perl_nurbs_error_callback ( GLenum errorCode )
  65 {
  66         ENTER_TLS_CONTEXT
  67         dSP;
  68
  69         ENTER;
  70         SAVETMPS;
  71         PUSHMARK(SP);
  72         XPUSHs(sv_2mortal(newSViv(errorCode)));
  73         PUTBACK;
  74
  75         call_sv(sdl_perl_nurbs_error_hook,G_VOID);
  76
  77         FREETMPS;
  78         LEAVE;
  79         LEAVE_TLS_CONTEXT
  80 }
  81
  82 void
  83 sdl_perl_nurbs_being_callback ( GLenum type, void *cb )
  84 {
  85         SV *cmd;
  86         ENTER_TLS_CONTEXT
  87         dSP;
  88
  89         cmd = (SV*)cb;
  90
  91         ENTER;
  92         SAVETMPS;
  93         PUSHMARK(SP);
  94         XPUSHs(sv_2mortal(newSViv(type)));
  95         PUTBACK;
  96
  97         call_sv(cmd,G_VOID);
  98
  99         FREETMPS;
 100         LEAVE;
 101         LEAVE_TLS_CONTEXT
 102 }
 103
 104 void
 105 sdl_perl_nurbs_multi_callback ( GLfloat *vec, void *cb )
 106 {
 107         SV *cmd;
 108         ENTER_TLS_CONTEXT
 109         dSP;
 110
 111         cmd = (SV*)cb;
 112
 113         ENTER;
 114         SAVETMPS;
 115         PUSHMARK(SP);
 116         XPUSHs(sv_2mortal(newSViv(PTR2IV(vec))));
 117         PUTBACK;
 118
 119         call_sv(cmd,G_VOID);
 120
 121         FREETMPS;
 122         LEAVE;
 123         LEAVE_TLS_CONTEXT
 124 }
 125
 126 void
 127 sdl_perl_nurbs_end_callback ( void *cb )
 128 {
 129         SV *cmd;
 130         ENTER_TLS_CONTEXT
 131
 132         cmd = (SV*)cb;
 133
 134         ENTER;
 135         SAVETMPS;
 136
 137         call_sv(cmd,G_VOID);
 138
 139         FREETMPS;
 140         LEAVE;
 141         LEAVE_TLS_CONTEXT
 142 }
 143
 144 void
 145 sdl_perl_tess_end_callback ( void *cb )
 146 {
 147         SV *cmd;
 148         ENTER_TLS_CONTEXT
 149         dSP;
 150
 151         cmd = (SV*)cb;
 152
 153         ENTER;
 154         SAVETMPS;
 155         PUSHMARK(SP);
 156         XPUSHs(sv_2mortal(newSViv(GLU_TESS_BEGIN)));
 157         PUTBACK;
 158
 159         call_sv(cmd,G_VOID);
 160
 161         FREETMPS;
 162         LEAVE;
 163         LEAVE_TLS_CONTEXT
 164 }
 165
 166 void
 167 sdl_perl_tess_begin_callback ( GLenum type,  void *cb )
 168 {
 169         SV *cmd;
 170         ENTER_TLS_CONTEXT
 171         dSP;
 172
 173         cmd = (SV*)cb;
 174
 175         ENTER;
 176         SAVETMPS;
 177         PUSHMARK(SP);
 178         XPUSHs(sv_2mortal(newSViv(GLU_TESS_BEGIN)));
 179         XPUSHs(sv_2mortal(newSViv(type)));
 180         PUTBACK;
 181
 182         call_sv(cmd,G_VOID);
 183
 184         FREETMPS;
 185         LEAVE;
 186         LEAVE_TLS_CONTEXT
 187 }
 188
 189 void
 190 sdl_perl_tess_error_callback ( GLenum type,  void *cb )
 191 {
 192         SV *cmd;
 193         ENTER_TLS_CONTEXT
 194         dSP;
 195
 196         cmd = (SV*)cb;
 197
 198         ENTER;
 199         SAVETMPS;
 200         PUSHMARK(SP);
 201         XPUSHs(sv_2mortal(newSViv(GLU_TESS_ERROR)));
 202         XPUSHs(sv_2mortal(newSViv(type)));
 203         PUTBACK;
 204
 205         call_sv(cmd,G_VOID);
 206
 207         FREETMPS;
 208         LEAVE;
 209         LEAVE_TLS_CONTEXT
 210 }
 211
 212 void
 213 sdl_perl_tess_edge_flag_callback ( GLenum flag,  void *cb )
 214 {
 215         SV *cmd;
 216         ENTER_TLS_CONTEXT
 217         dSP;
 218
 219         cmd = (SV*)cb;
 220
 221         ENTER;
 222         SAVETMPS;
 223         PUSHMARK(SP);
 224         XPUSHs(sv_2mortal(newSViv(GLU_TESS_EDGE_FLAG)));
 225         XPUSHs(sv_2mortal(newSViv(flag)));
 226         PUTBACK;
 227
 228         call_sv(cmd,G_VOID);
 229
 230         FREETMPS;
 231         LEAVE;
 232         LEAVE_TLS_CONTEXT
 233 }
 234
 235 void
 236 sdl_perl_tess_vertex_callback ( double *vd,  void *cb )
 237 {
 238         SV *cmd;
 239         ENTER_TLS_CONTEXT
 240         dSP;
 241
 242         cmd = (SV*)cb;
 243
 244         ENTER;
 245         SAVETMPS;
 246         PUSHMARK(SP);
 247         XPUSHs(sv_2mortal(newSViv(GLU_TESS_VERTEX)));
 248         XPUSHs(sv_2mortal(newSVnv(vd[0])));
 249         XPUSHs(sv_2mortal(newSVnv(vd[1])));
 250         XPUSHs(sv_2mortal(newSVnv(vd[2])));
 251         XPUSHs(sv_2mortal(newSVnv(vd[3])));
 252         XPUSHs(sv_2mortal(newSVnv(vd[4])));
 253         XPUSHs(sv_2mortal(newSVnv(vd[5])));
 254         PUTBACK;
 255
 256         call_sv(cmd,G_VOID);
 257
 258         FREETMPS;
 259         LEAVE;
 260         LEAVE_TLS_CONTEXT
 261 }
 262
 263 void
 264 sdl_perl_tess_combine_callback ( GLdouble coords[3], double *vd[4], GLfloat weight[4],
 265         GLdouble **out, void *cb )
 266 {
 267         SV *cmd;
 268         double *data;
 269         int width;
 270         ENTER_TLS_CONTEXT
 271         dSP;
 272
 273         cmd = (SV*)cb;
 274
 275         ENTER;
 276         SAVETMPS;
 277         PUSHMARK(SP);
 278         XPUSHs(sv_2mortal(newSViv(GLU_TESS_COMBINE)));
 279         XPUSHs(sv_2mortal(newSVpvn((char*)coords,sizeof(GLdouble)*3)));
 280         XPUSHs(sv_2mortal(newSVpvn((char*)vd,sizeof(GLdouble*)*4)));
 281         XPUSHs(sv_2mortal(newSVpvn((char*)weight,sizeof(GLfloat)*4)));
 282         PUTBACK;
 283
 284         if ( 1 != call_sv(cmd,G_SCALAR) ) {
 285                 Perl_croak(aTHX_ "sdl_perl_tess_combine_callback failed");
 286         }
 287
 288         data = (double*)POPp;
 289         width = (int)POPi;
 290         *out = (double*)malloc(sizeof(double)*width);
 291         memcpy(*out,data,sizeof(double)*width);
 292
 293         FREETMPS;
 294         LEAVE;
 295         LEAVE_TLS_CONTEXT
 296 }
 297
 298 #line 299 "OpenGL.c"
 299 #ifdef HAVE_GL
 300 #define XSubPPtmpAAAA 1
 301
 302 XS(XS_SDL__OpenGL_glClearColor); /* prototype to pass -Wmissing-prototypes */
 303 XS(XS_SDL__OpenGL_glClearColor)
 304 {
 305     dXSARGS;
 306     if (items != 4)
 307         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glClearColor(r, g, b, a)");
 308     {
 309         double  r = (double)SvNV(ST(0));
 310         double  g = (double)SvNV(ST(1));
 311         double  b = (double)SvNV(ST(2));
 312         double  a = (double)SvNV(ST(3));
 313 #line 301 "OpenGL.xs"
 314                 glClearColor((GLfloat)r,(GLfloat)g,(GLfloat)b,(GLfloat)a);
 315 #line 316 "OpenGL.c"
 316     }
 317     XSRETURN_EMPTY;
 318 }
 319
 320 XS(XS_SDL__OpenGL_glClearIndex); /* prototype to pass -Wmissing-prototypes */
 321 XS(XS_SDL__OpenGL_glClearIndex)
 322 {
 323     dXSARGS;
 324     if (items != 1)
 325         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glClearIndex(index)");
 326     {
 327         double  index = (double)SvNV(ST(0));
 328 #line 307 "OpenGL.xs"
 329                 glClearIndex(index);
 330 #line 331 "OpenGL.c"
 331     }
 332     XSRETURN_EMPTY;
 333 }
 334
 335 XS(XS_SDL__OpenGL_glClearDepth); /* prototype to pass -Wmissing-prototypes */
 336 XS(XS_SDL__OpenGL_glClearDepth)
 337 {
 338     dXSARGS;
 339     if (items != 1)
 340         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glClearDepth(depth)");
 341     {
 342         double  depth = (double)SvNV(ST(0));
 343 #line 313 "OpenGL.xs"
 344                 glClearDepth(depth);
 345 #line 346 "OpenGL.c"
 346     }
 347     XSRETURN_EMPTY;
 348 }
 349
 350 XS(XS_SDL__OpenGL_glClearStencil); /* prototype to pass -Wmissing-prototypes */
 351 XS(XS_SDL__OpenGL_glClearStencil)
 352 {
 353     dXSARGS;
 354     if (items != 1)
 355         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glClearStencil(s)");
 356     {
 357         int     s = (int)SvIV(ST(0));
 358 #line 319 "OpenGL.xs"
 359                 glClearStencil(s);
 360 #line 361 "OpenGL.c"
 361     }
 362     XSRETURN_EMPTY;
 363 }
 364
 365 XS(XS_SDL__OpenGL_glClearAccum); /* prototype to pass -Wmissing-prototypes */
 366 XS(XS_SDL__OpenGL_glClearAccum)
 367 {
 368     dXSARGS;
 369     if (items != 4)
 370         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glClearAccum(r, g, b, a)");
 371     {
 372         double  r = (double)SvNV(ST(0));
 373         double  g = (double)SvNV(ST(1));
 374         double  b = (double)SvNV(ST(2));
 375         double  a = (double)SvNV(ST(3));
 376 #line 328 "OpenGL.xs"
 377                 glClearAccum((GLfloat)r,(GLfloat)g,(GLfloat)b,(GLfloat)a);
 378 #line 379 "OpenGL.c"
 379     }
 380     XSRETURN_EMPTY;
 381 }
 382
 383 XS(XS_SDL__OpenGL_glClear); /* prototype to pass -Wmissing-prototypes */
 384 XS(XS_SDL__OpenGL_glClear)
 385 {
 386     dXSARGS;
 387     if (items != 1)
 388         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glClear(m)");
 389     {
 390         GLbitfield      m = (GLbitfield)SvIV(ST(0));
 391 #line 334 "OpenGL.xs"
 392                 glClear(m);
 393 #line 394 "OpenGL.c"
 394     }
 395     XSRETURN_EMPTY;
 396 }
 397
 398 XS(XS_SDL__OpenGL_glFlush); /* prototype to pass -Wmissing-prototypes */
 399 XS(XS_SDL__OpenGL_glFlush)
 400 {
 401     dXSARGS;
 402     if (items != 0)
 403         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glFlush()");
 404     {
 405 #line 339 "OpenGL.xs"
 406                 glFlush();
 407 #line 408 "OpenGL.c"
 408     }
 409     XSRETURN_EMPTY;
 410 }
 411
 412 XS(XS_SDL__OpenGL_glFinish); /* prototype to pass -Wmissing-prototypes */
 413 XS(XS_SDL__OpenGL_glFinish)
 414 {
 415     dXSARGS;
 416     if (items != 0)
 417         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glFinish()");
 418     {
 419 #line 344 "OpenGL.xs"
 420                 glFinish();
 421 #line 422 "OpenGL.c"
 422     }
 423     XSRETURN_EMPTY;
 424 }
 425
 426 XS(XS_SDL__OpenGL_glRect); /* prototype to pass -Wmissing-prototypes */
 427 XS(XS_SDL__OpenGL_glRect)
 428 {
 429     dXSARGS;
 430     if (items != 1)
 431         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glRect(r)");
 432     {
 433         SDL_Rect*       r = INT2PTR(SDL_Rect *,SvIV(ST(0)));
 434 #line 350 "OpenGL.xs"
 435                 glRecti(r->x,r->y,r->x+r->w,r->y+r->h);
 436 #line 437 "OpenGL.c"
 437     }
 438     XSRETURN_EMPTY;
 439 }
 440
 441 XS(XS_SDL__OpenGL_glVertex); /* prototype to pass -Wmissing-prototypes */
 442 XS(XS_SDL__OpenGL_glVertex)
 443 {
 444     dXSARGS;
 445     if (items < 2)
 446         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glVertex(x, y, ...)");
 447     {
 448         double  x = (double)SvNV(ST(0));
 449         double  y = (double)SvNV(ST(1));
 450 #line 357 "OpenGL.xs"
 451                 double z,w;
 452                 if ( items == 4 ) {
 453                         w = SvNV(ST(3));
 454                         z = SvNV(ST(2));
 455                         glVertex4d(x,y,z,w);
 456                 } else if ( items == 3 ) {
 457                         z = SvNV(ST(2));
 458                         glVertex3d(x,y,z);
 459                 } else {
 460                         glVertex2d(x,y);
 461                 }
 462 #line 463 "OpenGL.c"
 463     }
 464     XSRETURN_EMPTY;
 465 }
 466
 467 XS(XS_SDL__OpenGL_glBegin); /* prototype to pass -Wmissing-prototypes */
 468 XS(XS_SDL__OpenGL_glBegin)
 469 {
 470     dXSARGS;
 471     if (items != 1)
 472         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glBegin(mode)");
 473     {
 474         GLenum  mode = (GLenum)SvIV(ST(0));
 475 #line 373 "OpenGL.xs"
 476                 glBegin(mode);
 477 #line 478 "OpenGL.c"
 478     }
 479     XSRETURN_EMPTY;
 480 }
 481
 482 XS(XS_SDL__OpenGL_glEnd); /* prototype to pass -Wmissing-prototypes */
 483 XS(XS_SDL__OpenGL_glEnd)
 484 {
 485     dXSARGS;
 486     if (items != 0)
 487         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glEnd()");
 488     {
 489 #line 378 "OpenGL.xs"
 490                 glEnd();
 491 #line 492 "OpenGL.c"
 492     }
 493     XSRETURN_EMPTY;
 494 }
 495
 496 XS(XS_SDL__OpenGL_glEnable); /* prototype to pass -Wmissing-prototypes */
 497 XS(XS_SDL__OpenGL_glEnable)
 498 {
 499     dXSARGS;
 500     if (items != 1)
 501         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glEnable(cap)");
 502     {
 503         GLenum  cap = (GLenum)SvIV(ST(0));
 504 #line 384 "OpenGL.xs"
 505                 glEnable(cap);
 506 #line 507 "OpenGL.c"
 507     }
 508     XSRETURN_EMPTY;
 509 }
 510
 511 XS(XS_SDL__OpenGL_glDisable); /* prototype to pass -Wmissing-prototypes */
 512 XS(XS_SDL__OpenGL_glDisable)
 513 {
 514     dXSARGS;
 515     if (items != 1)
 516         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDisable(cap)");
 517     {
 518         GLenum  cap = (GLenum)SvIV(ST(0));
 519 #line 390 "OpenGL.xs"
 520                 glDisable(cap);
 521 #line 522 "OpenGL.c"
 522     }
 523     XSRETURN_EMPTY;
 524 }
 525
 526 XS(XS_SDL__OpenGL_glGet); /* prototype to pass -Wmissing-prototypes */
 527 XS(XS_SDL__OpenGL_glGet)
 528 {
 529     dXSARGS;
 530     if (items != 1)
 531         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glGet(param)");
 532     SP -= items;
 533     {
 534         GLenum  param = (GLenum)SvIV(ST(0));
 535 #line 396 "OpenGL.xs"
 536         switch (param) {
 537         case GL_EDGE_FLAG_ARRAY:
 538         case GL_MAP1_TEXTURE_COORD_1:
 539         case GL_LIGHT_MODEL_TWO_SIDE:
 540         case GL_INDEX_LOGIC_OP:
 541         case GL_PACK_ALIGNMENT:
 542         case GL_CLIP_PLANE4:
 543         case GL_TEXTURE_GEN_S:
 544         case GL_MAP1_VERTEX_3:
 545         case GL_LIGHT6:
 546         case GL_LIGHT0:
 547         case GL_NORMAL_ARRAY:
 548         case GL_EDGE_FLAG:
 549         case GL_INDEX_ARRAY:
 550         case GL_AUTO_NORMAL:
 551         case GL_POLYGON_OFFSET_FILL:
 552         case GL_MAP1_TEXTURE_COORD_4:
 553         case GL_FOG:
 554         case GL_LIGHT2:
 555         case GL_UNPACK_SWAP_BYTES:
 556         case GL_RGBA_MODE:
 557         case GL_POLYGON_OFFSET_POINT:
 558         case GL_POINT_SMOOTH:
 559         case GL_ALPHA_TEST:
 560         case GL_MAP2_TEXTURE_COORD_4:
 561         case GL_COLOR_ARRAY:
 562         case GL_POLYGON_OFFSET_LINE:
 563         case GL_MAP2_NORMAL:
 564         case GL_MAP1_INDEX:
 565         case GL_PACK_LSB_FIRST:
 566         case GL_MAP1_TEXTURE_COORD_2:
 567         case GL_MAP2_VERTEX_3:
 568         case GL_MAP2_TEXTURE_COORD_2:
 569         case GL_CULL_FACE:
 570         case GL_DOUBLEBUFFER:
 571         case GL_UNPACK_LSB_FIRST:
 572         case GL_TEXTURE_COORD_ARRAY:
 573         case GL_LIGHT1:
 574         case GL_TEXTURE_GEN_Q:
 575         case GL_MAP_STENCIL:
 576         case GL_TEXTURE_1D:
 577         case GL_LIGHT4:
 578         case GL_LIGHTING:
 579         case GL_LIGHT7:
 580         case GL_MAP1_NORMAL:
 581         case GL_CLIP_PLANE0:
 582         case GL_TEXTURE_GEN_R:
 583         case GL_PACK_SWAP_BYTES:
 584         case GL_DEPTH_WRITEMASK:
 585         case GL_COLOR_LOGIC_OP:
 586         case GL_CLIP_PLANE5:
 587         case GL_NORMALIZE:
 588         case GL_TEXTURE_2D:
 589         case GL_CLIP_PLANE3:
 590         case GL_COLOR_MATERIAL:
 591         case GL_BLEND:
 592         case GL_CLIP_PLANE2:
 593         case GL_MAP1_VERTEX_4:
 594         case GL_DITHER:
 595         case GL_CLIP_PLANE1:
 596         case GL_MAP2_INDEX:
 597         case GL_POLYGON_SMOOTH:
 598         case GL_STEREO:
 599         case GL_MAP2_COLOR_4:
 600         case GL_LIGHT3:
 601         case GL_VERTEX_ARRAY:
 602         case GL_MAP1_TEXTURE_COORD_3:
 603         case GL_STENCIL_TEST:
 604         case GL_MAP2_TEXTURE_COORD_3:
 605         case GL_TEXTURE_GEN_T:
 606         case GL_LIGHT_MODEL_LOCAL_VIEWER:
 607         case GL_LINE_SMOOTH:
 608         case GL_MAP1_COLOR_4:
 609         case GL_MAP2_TEXTURE_COORD_1:
 610         case GL_CURRENT_RASTER_POSITION_VALID:
 611         case GL_INDEX_MODE:
 612         case GL_SCISSOR_TEST:
 613         case GL_MAP_COLOR:
 614         case GL_POLYGON_STIPPLE:
 615         case GL_LIGHT5:
 616         case GL_DEPTH_TEST:
 617         case GL_LINE_STIPPLE:
 618         case GL_MAP2_VERTEX_4:
 619         {
 620             GLboolean ret[1];
 621             int i;
 622             glGetBooleanv(param, ret);
 623
 624             for (i = 0; i < 1; i++) {
 625                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 626             }
 627             break;
 628         }
 629         case GL_COLOR_WRITEMASK:
 630         {
 631             GLboolean ret[4];
 632             int i;
 633             glGetBooleanv(param, ret);
 634
 635             for (i = 0; i < 4; i++) {
 636                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 637             }
 638             break;
 639         }
 640         case GL_ZOOM_Y:
 641         case GL_ALPHA_TEST_REF:
 642         case GL_POINT_SIZE_GRANULARITY:
 643         case GL_CURRENT_RASTER_DISTANCE:
 644         case GL_ALPHA_SCALE:
 645         case GL_RED_BIAS:
 646         case GL_DEPTH_BIAS:
 647         case GL_FOG_DENSITY:
 648         case GL_GREEN_BIAS:
 649         case GL_DEPTH_CLEAR_VALUE:
 650         case GL_ALPHA_BIAS:
 651         case GL_FOG_END:
 652         case GL_GREEN_SCALE:
 653         case GL_BLUE_BIAS:
 654         case GL_DEPTH_SCALE:
 655         case GL_POINT_SIZE:
 656         case GL_POLYGON_OFFSET_FACTOR:
 657         case GL_ZOOM_X:
 658         case GL_FOG_START:
 659         case GL_POLYGON_OFFSET_UNITS:
 660         case GL_LINE_WIDTH:
 661         case GL_LINE_WIDTH_GRANULARITY:
 662         case GL_BLUE_SCALE:
 663         case GL_RED_SCALE:
 664         {
 665             GLdouble ret[1];
 666             int i;
 667             glGetDoublev(param, ret);
 668
 669             for (i = 0; i < 1; i++) {
 670                 XPUSHs(sv_2mortal(newSVnv(ret[i])));
 671             }
 672             break;
 673         }
 674         case GL_MODELVIEW_MATRIX:
 675         case GL_TEXTURE_MATRIX:
 676         case GL_PROJECTION_MATRIX:
 677         {
 678             GLdouble ret[16];
 679             int i;
 680             glGetDoublev(param, ret);
 681
 682             for (i = 0; i < 16; i++) {
 683                 XPUSHs(sv_2mortal(newSVnv(ret[i])));
 684             }
 685             break;
 686         }
 687         case GL_POINT_SIZE_RANGE:
 688         case GL_LINE_WIDTH_RANGE:
 689         case GL_MAP1_GRID_DOMAIN:
 690         case GL_DEPTH_RANGE:
 691         {
 692             GLdouble ret[2];
 693             int i;
 694             glGetDoublev(param, ret);
 695
 696             for (i = 0; i < 2; i++) {
 697                 XPUSHs(sv_2mortal(newSVnv(ret[i])));
 698             }
 699             break;
 700         }
 701         case GL_CURRENT_NORMAL:
 702         {
 703             GLdouble ret[3];
 704             int i;
 705             glGetDoublev(param, ret);
 706
 707             for (i = 0; i < 3; i++) {
 708                 XPUSHs(sv_2mortal(newSVnv(ret[i])));
 709             }
 710             break;
 711         }
 712         case GL_FOG_COLOR:
 713         case GL_MAP2_GRID_DOMAIN:
 714         case GL_CURRENT_RASTER_POSITION:
 715         case GL_CURRENT_COLOR:
 716         case GL_LIGHT_MODEL_AMBIENT:
 717         case GL_CURRENT_RASTER_TEXTURE_COORDS:
 718         case GL_TEXTURE_ENV_COLOR:
 719         case GL_CURRENT_RASTER_COLOR:
 720         case GL_CURRENT_TEXTURE_COORDS:
 721         case GL_COLOR_CLEAR_VALUE:
 722         case GL_ACCUM_CLEAR_VALUE:
 723         {
 724             GLdouble ret[4];
 725             int i;
 726             glGetDoublev(param, ret);
 727
 728             for (i = 0; i < 4; i++) {
 729                 XPUSHs(sv_2mortal(newSVnv(ret[i])));
 730             }
 731             break;
 732         }
 733         case GL_CULL_FACE_MODE:
 734         case GL_PIXEL_MAP_I_TO_A_SIZE:
 735         case GL_PIXEL_MAP_A_TO_A_SIZE:
 736         case GL_BLUE_BITS:
 737         case GL_EDGE_FLAG_ARRAY_STRIDE:
 738         case GL_RENDER_MODE:
 739         case GL_FOG_MODE:
 740         case GL_DEPTH_FUNC:
 741         case GL_READ_BUFFER:
 742         case GL_POINT_SMOOTH_HINT:
 743         case GL_PACK_SKIP_PIXELS:
 744         case GL_STENCIL_REF:
 745         case GL_STENCIL_CLEAR_VALUE:
 746         case GL_AUX_BUFFERS:
 747         case GL_COLOR_MATERIAL_PARAMETER:
 748         case GL_ACCUM_BLUE_BITS:
 749         case GL_INDEX_SHIFT:
 750         case GL_VERTEX_ARRAY_STRIDE:
 751         case GL_STENCIL_PASS_DEPTH_PASS:
 752         case GL_CLIENT_ATTRIB_STACK_DEPTH:
 753         case GL_DRAW_BUFFER:
 754         case GL_LINE_STIPPLE_REPEAT:
 755         case GL_BLEND_SRC:
 756         case GL_PIXEL_MAP_B_TO_B_SIZE:
 757         case GL_MAX_PIXEL_MAP_TABLE:
 758         case GL_MAX_TEXTURE_SIZE:
 759         case GL_PIXEL_MAP_S_TO_S_SIZE:
 760         case GL_LOGIC_OP_MODE:
 761         case GL_DEPTH_BITS:
 762         case GL_GREEN_BITS:
 763         case GL_LINE_SMOOTH_HINT:
 764         case GL_ALPHA_TEST_FUNC:
 765         case GL_MAX_LIGHTS:
 766         case GL_FOG_HINT:
 767         case GL_MAX_NAME_STACK_DEPTH:
 768         case GL_INDEX_ARRAY_TYPE:
 769         case GL_TEXTURE_COORD_ARRAY_TYPE:
 770         case GL_COLOR_ARRAY_TYPE:
 771         case GL_MAX_LIST_NESTING:
 772         case GL_STENCIL_WRITEMASK:
 773         case GL_LIST_BASE:
 774         case GL_ACCUM_ALPHA_BITS:
 775         case GL_INDEX_ARRAY_STRIDE:
 776         case GL_PIXEL_MAP_I_TO_B_SIZE:
 777         case GL_INDEX_BITS:
 778         case GL_STENCIL_FAIL:
 779         case GL_UNPACK_ALIGNMENT:
 780         case GL_STENCIL_PASS_DEPTH_FAIL:
 781         case GL_ATTRIB_STACK_DEPTH:
 782         case GL_PACK_SKIP_ROWS:
 783         case GL_TEXTURE_STACK_DEPTH:
 784         case GL_MATRIX_MODE:
 785         case GL_COLOR_ARRAY_STRIDE:
 786         case GL_LIST_MODE:
 787         case GL_UNPACK_SKIP_PIXELS:
 788         case GL_PIXEL_MAP_G_TO_G_SIZE:
 789         case GL_VERTEX_ARRAY_TYPE:
 790         case GL_RED_BITS:
 791         case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
 792         case GL_INDEX_CLEAR_VALUE:
 793         case GL_PIXEL_MAP_I_TO_G_SIZE:
 794         case GL_ALPHA_BITS:
 795         case GL_PIXEL_MAP_I_TO_R_SIZE:
 796         case GL_COLOR_ARRAY_SIZE:
 797         case GL_TEXTURE_COORD_ARRAY_SIZE:
 798         case GL_MAP1_GRID_SEGMENTS:
 799         case GL_VERTEX_ARRAY_SIZE:
 800         case GL_PIXEL_MAP_R_TO_R_SIZE:
 801         case GL_TEXTURE_COORD_ARRAY_STRIDE:
 802         case GL_MODELVIEW_STACK_DEPTH:
 803         case GL_MAX_TEXTURE_STACK_DEPTH:
 804         case GL_PIXEL_MAP_I_TO_I_SIZE:
 805         case GL_FOG_INDEX:
 806         case GL_INDEX_WRITEMASK:
 807         case GL_PACK_ROW_LENGTH:
 808         case GL_CURRENT_INDEX:
 809         case GL_STENCIL_VALUE_MASK:
 810         case GL_UNPACK_SKIP_ROWS:
 811         case GL_MAX_PROJECTION_STACK_DEPTH:
 812         case GL_LIST_INDEX:
 813         case GL_STENCIL_FUNC:
 814         case GL_INDEX_OFFSET:
 815         case GL_UNPACK_ROW_LENGTH:
 816         case GL_COLOR_MATERIAL_FACE:
 817         case GL_NORMAL_ARRAY_TYPE:
 818         case GL_STENCIL_BITS:
 819         case GL_PROJECTION_STACK_DEPTH:
 820         case GL_CURRENT_RASTER_INDEX:
 821         case GL_SHADE_MODEL:
 822         case GL_TEXTURE_ENV_MODE:
 823         case GL_NORMAL_ARRAY_STRIDE:
 824         case GL_PERSPECTIVE_CORRECTION_HINT:
 825         case GL_MAX_CLIP_PLANES:
 826         case GL_MAX_MODELVIEW_STACK_DEPTH:
 827         case GL_SUBPIXEL_BITS:
 828         case GL_ACCUM_RED_BITS:
 829         case GL_BLEND_DST:
 830         case GL_FRONT_FACE:
 831         case GL_MAX_EVAL_ORDER:
 832         case GL_LINE_STIPPLE_PATTERN:
 833         case GL_NAME_STACK_DEPTH:
 834         case GL_MAX_ATTRIB_STACK_DEPTH:
 835         case GL_POLYGON_SMOOTH_HINT:
 836         case GL_ACCUM_GREEN_BITS:
 837         {
 838             GLint ret[1];
 839             int i;
 840             glGetIntegerv(param, ret);
 841
 842             for (i = 0; i < 1; i++) {
 843                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 844             }
 845             break;
 846         }
 847         case GL_POLYGON_MODE:
 848         case GL_MAX_VIEWPORT_DIMS:
 849         case GL_MAP2_GRID_SEGMENTS:
 850         {
 851             GLint ret[2];
 852             int i;
 853             glGetIntegerv(param, ret);
 854
 855             for (i = 0; i < 2; i++) {
 856                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 857             }
 858             break;
 859         }
 860         case GL_SCISSOR_BOX:
 861         case GL_VIEWPORT:
 862         {
 863             GLint ret[4];
 864             int i;
 865             glGetIntegerv(param, ret);
 866
 867             for (i = 0; i < 4; i++) {
 868                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 869             }
 870             break;
 871         }
 872         default:
 873             croak("Unknown glGet parameter!");
 874         }
 875 #line 876 "OpenGL.c"
 876         PUTBACK;
 877         return;
 878     }
 879 }
 880
 881 XS(XS_SDL__OpenGL_glIsEnabled); /* prototype to pass -Wmissing-prototypes */
 882 XS(XS_SDL__OpenGL_glIsEnabled)
 883 {
 884     dXSARGS;
 885     if (items != 1)
 886         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glIsEnabled(cap)");
 887     {
 888         Uint32  cap = (Uint32)SvUV(ST(0));
 889         Uint32  RETVAL;
 890         dXSTARG;
 891 #line 741 "OpenGL.xs"
 892                 RETVAL = glIsEnabled(cap);
 893 #line 894 "OpenGL.c"
 894         XSprePUSH; PUSHu((UV)RETVAL);
 895     }
 896     XSRETURN(1);
 897 }
 898
 899 XS(XS_SDL__OpenGL_glPointSize); /* prototype to pass -Wmissing-prototypes */
 900 XS(XS_SDL__OpenGL_glPointSize)
 901 {
 902     dXSARGS;
 903     if (items != 1)
 904         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPointSize(size)");
 905     {
 906         double  size = (double)SvNV(ST(0));
 907 #line 749 "OpenGL.xs"
 908                 glPointSize((GLfloat)size);
 909 #line 910 "OpenGL.c"
 910     }
 911     XSRETURN_EMPTY;
 912 }
 913
 914 XS(XS_SDL__OpenGL_glLineWidth); /* prototype to pass -Wmissing-prototypes */
 915 XS(XS_SDL__OpenGL_glLineWidth)
 916 {
 917     dXSARGS;
 918     if (items != 1)
 919         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glLineWidth(size)");
 920     {
 921         double  size = (double)SvNV(ST(0));
 922 #line 755 "OpenGL.xs"
 923                 glLineWidth((GLfloat)size);
 924 #line 925 "OpenGL.c"
 925     }
 926     XSRETURN_EMPTY;
 927 }
 928
 929 XS(XS_SDL__OpenGL_glLineStipple); /* prototype to pass -Wmissing-prototypes */
 930 XS(XS_SDL__OpenGL_glLineStipple)
 931 {
 932     dXSARGS;
 933     if (items != 2)
 934         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glLineStipple(factor, pattern)");
 935     {
 936         Sint32  factor = (Sint32)SvIV(ST(0));
 937         Uint16  pattern = (Uint16)SvUV(ST(1));
 938 #line 762 "OpenGL.xs"
 939                 glLineStipple(factor,pattern);
 940 #line 941 "OpenGL.c"
 941     }
 942     XSRETURN_EMPTY;
 943 }
 944
 945 XS(XS_SDL__OpenGL_glPolygonMode); /* prototype to pass -Wmissing-prototypes */
 946 XS(XS_SDL__OpenGL_glPolygonMode)
 947 {
 948     dXSARGS;
 949     if (items != 2)
 950         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPolygonMode(face, mode)");
 951     {
 952         GLenum  face = (GLenum)SvIV(ST(0));
 953         GLenum  mode = (GLenum)SvIV(ST(1));
 954 #line 769 "OpenGL.xs"
 955                 glPolygonMode(face,mode);
 956 #line 957 "OpenGL.c"
 957     }
 958     XSRETURN_EMPTY;
 959 }
 960
 961 XS(XS_SDL__OpenGL_glFrontFace); /* prototype to pass -Wmissing-prototypes */
 962 XS(XS_SDL__OpenGL_glFrontFace)
 963 {
 964     dXSARGS;
 965     if (items != 1)
 966         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glFrontFace(mode)");
 967     {
 968         GLenum  mode = (GLenum)SvIV(ST(0));
 969 #line 775 "OpenGL.xs"
 970                 glFrontFace(mode);
 971 #line 972 "OpenGL.c"
 972     }
 973     XSRETURN_EMPTY;
 974 }
 975
 976 XS(XS_SDL__OpenGL_glCullFace); /* prototype to pass -Wmissing-prototypes */
 977 XS(XS_SDL__OpenGL_glCullFace)
 978 {
 979     dXSARGS;
 980     if (items != 1)
 981         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCullFace(mode)");
 982     {
 983         GLenum  mode = (GLenum)SvIV(ST(0));
 984 #line 781 "OpenGL.xs"
 985                 glCullFace(mode);
 986 #line 987 "OpenGL.c"
 987     }
 988     XSRETURN_EMPTY;
 989 }
 990
 991 XS(XS_SDL__OpenGL_glPolygonStipple); /* prototype to pass -Wmissing-prototypes */
 992 XS(XS_SDL__OpenGL_glPolygonStipple)
 993 {
 994     dXSARGS;
 995     if (items != 1)
 996         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPolygonStipple(mask)");
 997     {
 998         char *  mask = (char *)SvPV_nolen(ST(0));
 999 #line 787 "OpenGL.xs"
1000                 glPolygonStipple(mask);
1001 #line 1002 "OpenGL.c"
1002     }
1003     XSRETURN_EMPTY;
1004 }
1005
1006 XS(XS_SDL__OpenGL_glEdgeFlag); /* prototype to pass -Wmissing-prototypes */
1007 XS(XS_SDL__OpenGL_glEdgeFlag)
1008 {
1009     dXSARGS;
1010     if (items != 1)
1011         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glEdgeFlag(flag)");
1012     {
1013         GLenum  flag = (GLenum)SvIV(ST(0));
1014 #line 793 "OpenGL.xs"
1015                 glEdgeFlag(flag);
1016 #line 1017 "OpenGL.c"
1017     }
1018     XSRETURN_EMPTY;
1019 }
1020
1021 XS(XS_SDL__OpenGL_glNormal); /* prototype to pass -Wmissing-prototypes */
1022 XS(XS_SDL__OpenGL_glNormal)
1023 {
1024     dXSARGS;
1025     if (items != 3)
1026         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glNormal(x, y, z)");
1027     {
1028         double  x = (double)SvNV(ST(0));
1029         double  y = (double)SvNV(ST(1));
1030         double  z = (double)SvNV(ST(2));
1031 #line 801 "OpenGL.xs"
1032                 glNormal3d(x,y,z);
1033 #line 1034 "OpenGL.c"
1034     }
1035     XSRETURN_EMPTY;
1036 }
1037
1038 XS(XS_SDL__OpenGL_glEnableClientState); /* prototype to pass -Wmissing-prototypes */
1039 XS(XS_SDL__OpenGL_glEnableClientState)
1040 {
1041     dXSARGS;
1042     if (items != 1)
1043         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glEnableClientState(array)");
1044     {
1045         GLenum  array = (GLenum)SvIV(ST(0));
1046 #line 807 "OpenGL.xs"
1047                 glEnableClientState(array);
1048 #line 1049 "OpenGL.c"
1049     }
1050     XSRETURN_EMPTY;
1051 }
1052
1053 XS(XS_SDL__OpenGL_glDisableClientState); /* prototype to pass -Wmissing-prototypes */
1054 XS(XS_SDL__OpenGL_glDisableClientState)
1055 {
1056     dXSARGS;
1057     if (items != 1)
1058         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDisableClientState(array)");
1059     {
1060         GLenum  array = (GLenum)SvIV(ST(0));
1061 #line 813 "OpenGL.xs"
1062                 glDisableClientState(array);
1063 #line 1064 "OpenGL.c"
1064     }
1065     XSRETURN_EMPTY;
1066 }
1067
1068 XS(XS_SDL__OpenGL_glVertexPointer); /* prototype to pass -Wmissing-prototypes */
1069 XS(XS_SDL__OpenGL_glVertexPointer)
1070 {
1071     dXSARGS;
1072     if (items != 4)
1073         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glVertexPointer(size, type, stride, pointer)");
1074     {
1075         int     size = (int)SvIV(ST(0));
1076         GLenum  type = (GLenum)SvIV(ST(1));
1077         Uint32  stride = (Uint32)SvUV(ST(2));
1078         char *  pointer = (char *)SvPV_nolen(ST(3));
1079 #line 822 "OpenGL.xs"
1080                 glVertexPointer(size,type,stride,pointer);
1081 #line 1082 "OpenGL.c"
1082     }
1083     XSRETURN_EMPTY;
1084 }
1085
1086 XS(XS_SDL__OpenGL_glColorPointer); /* prototype to pass -Wmissing-prototypes */
1087 XS(XS_SDL__OpenGL_glColorPointer)
1088 {
1089     dXSARGS;
1090     if (items != 4)
1091         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glColorPointer(size, type, stride, pointer)");
1092     {
1093         Sint32  size = (Sint32)SvIV(ST(0));
1094         GLenum  type = (GLenum)SvIV(ST(1));
1095         Uint32  stride = (Uint32)SvUV(ST(2));
1096         char *  pointer = (char *)SvPV_nolen(ST(3));
1097 #line 831 "OpenGL.xs"
1098                 glColorPointer(size,type,stride,pointer);
1099 #line 1100 "OpenGL.c"
1100     }
1101     XSRETURN_EMPTY;
1102 }
1103
1104 XS(XS_SDL__OpenGL_glNormalPointer); /* prototype to pass -Wmissing-prototypes */
1105 XS(XS_SDL__OpenGL_glNormalPointer)
1106 {
1107     dXSARGS;
1108     if (items != 3)
1109         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glNormalPointer(type, stride, pointer)");
1110     {
1111         GLenum  type = (GLenum)SvIV(ST(0));
1112         Uint32  stride = (Uint32)SvUV(ST(1));
1113         char *  pointer = (char *)SvPV_nolen(ST(2));
1114 #line 839 "OpenGL.xs"
1115                 glNormalPointer(type,stride,pointer);
1116 #line 1117 "OpenGL.c"
1117     }
1118     XSRETURN_EMPTY;
1119 }
1120
1121 XS(XS_SDL__OpenGL_glTexCoordPointer); /* prototype to pass -Wmissing-prototypes */
1122 XS(XS_SDL__OpenGL_glTexCoordPointer)
1123 {
1124     dXSARGS;
1125     if (items != 4)
1126         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTexCoordPointer(size, type, stride, pointer)");
1127     {
1128         Sint32  size = (Sint32)SvIV(ST(0));
1129         GLenum  type = (GLenum)SvIV(ST(1));
1130         Uint32  stride = (Uint32)SvUV(ST(2));
1131         char *  pointer = (char *)SvPV_nolen(ST(3));
1132 #line 848 "OpenGL.xs"
1133                 glTexCoordPointer(size,type,stride,pointer);
1134 #line 1135 "OpenGL.c"
1135     }
1136     XSRETURN_EMPTY;
1137 }
1138
1139 XS(XS_SDL__OpenGL_glEdgeFlagPointer); /* prototype to pass -Wmissing-prototypes */
1140 XS(XS_SDL__OpenGL_glEdgeFlagPointer)
1141 {
1142     dXSARGS;
1143     if (items != 2)
1144         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glEdgeFlagPointer(stride, pointer)");
1145     {
1146         Uint32  stride = (Uint32)SvUV(ST(0));
1147         char *  pointer = (char *)SvPV_nolen(ST(1));
1148 #line 855 "OpenGL.xs"
1149                 glEdgeFlagPointer(stride,pointer);
1150 #line 1151 "OpenGL.c"
1151     }
1152     XSRETURN_EMPTY;
1153 }
1154
1155 XS(XS_SDL__OpenGL_glArrayElement); /* prototype to pass -Wmissing-prototypes */
1156 XS(XS_SDL__OpenGL_glArrayElement)
1157 {
1158     dXSARGS;
1159     if (items != 1)
1160         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glArrayElement(ith)");
1161     {
1162         Uint32  ith = (Uint32)SvUV(ST(0));
1163 #line 861 "OpenGL.xs"
1164                 glArrayElement(ith);
1165 #line 1166 "OpenGL.c"
1166     }
1167     XSRETURN_EMPTY;
1168 }
1169
1170 XS(XS_SDL__OpenGL_glDrawElements); /* prototype to pass -Wmissing-prototypes */
1171 XS(XS_SDL__OpenGL_glDrawElements)
1172 {
1173     dXSARGS;
1174     if (items != 4)
1175         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDrawElements(mode, count, type, indices)");
1176     {
1177         GLenum  mode = (GLenum)SvIV(ST(0));
1178         Uint32  count = (Uint32)SvUV(ST(1));
1179         GLenum  type = (GLenum)SvIV(ST(2));
1180         char *  indices = (char *)SvPV_nolen(ST(3));
1181 #line 870 "OpenGL.xs"
1182                 glDrawElements( mode, count, type, indices);
1183 #line 1184 "OpenGL.c"
1184     }
1185     XSRETURN_EMPTY;
1186 }
1187
1188 XS(XS_SDL__OpenGL_glDrawRangeElements); /* prototype to pass -Wmissing-prototypes */
1189 XS(XS_SDL__OpenGL_glDrawRangeElements)
1190 {
1191     dXSARGS;
1192     if (items != 6)
1193         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDrawRangeElements(mode, start, end, count, type, indices)");
1194     {
1195         GLenum  mode = (GLenum)SvIV(ST(0));
1196         Uint32  start = (Uint32)SvUV(ST(1));
1197         Uint32  end = (Uint32)SvUV(ST(2));
1198         Uint32  count = (Uint32)SvUV(ST(3));
1199         GLenum  type = (GLenum)SvIV(ST(4));
1200         char *  indices = (char *)SvPV_nolen(ST(5));
1201 #line 881 "OpenGL.xs"
1202                 glDrawRangeElements(mode,start,end,count,type,indices);
1203 #line 1204 "OpenGL.c"
1204     }
1205     XSRETURN_EMPTY;
1206 }
1207
1208 XS(XS_SDL__OpenGL_glDrawArrays); /* prototype to pass -Wmissing-prototypes */
1209 XS(XS_SDL__OpenGL_glDrawArrays)
1210 {
1211     dXSARGS;
1212     if (items != 3)
1213         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDrawArrays(mode, first, count)");
1214     {
1215         GLenum  mode = (GLenum)SvIV(ST(0));
1216         Uint32  first = (Uint32)SvUV(ST(1));
1217         Uint32  count = (Uint32)SvUV(ST(2));
1218 #line 889 "OpenGL.xs"
1219                 glDrawArrays(mode,first,count);
1220 #line 1221 "OpenGL.c"
1221     }
1222     XSRETURN_EMPTY;
1223 }
1224
1225 XS(XS_SDL__OpenGL_glInterleavedArrays); /* prototype to pass -Wmissing-prototypes */
1226 XS(XS_SDL__OpenGL_glInterleavedArrays)
1227 {
1228     dXSARGS;
1229     if (items != 3)
1230         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glInterleavedArrays(format, stride, pointer)");
1231     {
1232         GLenum  format = (GLenum)SvIV(ST(0));
1233         Uint32  stride = (Uint32)SvUV(ST(1));
1234         char *  pointer = (char *)SvPV_nolen(ST(2));
1235 #line 897 "OpenGL.xs"
1236                 glInterleavedArrays(format,stride,pointer);
1237 #line 1238 "OpenGL.c"
1238     }
1239     XSRETURN_EMPTY;
1240 }
1241
1242 XS(XS_SDL__OpenGL_glPushAttrib); /* prototype to pass -Wmissing-prototypes */
1243 XS(XS_SDL__OpenGL_glPushAttrib)
1244 {
1245     dXSARGS;
1246     if (items != 1)
1247         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPushAttrib(mask)");
1248     {
1249         GLbitfield      mask = (GLbitfield)SvIV(ST(0));
1250 #line 903 "OpenGL.xs"
1251                 glPushAttrib(mask);
1252 #line 1253 "OpenGL.c"
1253     }
1254     XSRETURN_EMPTY;
1255 }
1256
1257 XS(XS_SDL__OpenGL_glPopAttrib); /* prototype to pass -Wmissing-prototypes */
1258 XS(XS_SDL__OpenGL_glPopAttrib)
1259 {
1260     dXSARGS;
1261     if (items != 0)
1262         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPopAttrib()");
1263     {
1264 #line 908 "OpenGL.xs"
1265                 glPopAttrib();
1266 #line 1267 "OpenGL.c"
1267     }
1268     XSRETURN_EMPTY;
1269 }
1270
1271 XS(XS_SDL__OpenGL_glPushClientAttrib); /* prototype to pass -Wmissing-prototypes */
1272 XS(XS_SDL__OpenGL_glPushClientAttrib)
1273 {
1274     dXSARGS;
1275     if (items != 1)
1276         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPushClientAttrib(mask)");
1277     {
1278         GLbitfield      mask = (GLbitfield)SvIV(ST(0));
1279 #line 914 "OpenGL.xs"
1280                 glPushClientAttrib(mask);
1281 #line 1282 "OpenGL.c"
1282     }
1283     XSRETURN_EMPTY;
1284 }
1285
1286 XS(XS_SDL__OpenGL_glPopClientAttrib); /* prototype to pass -Wmissing-prototypes */
1287 XS(XS_SDL__OpenGL_glPopClientAttrib)
1288 {
1289     dXSARGS;
1290     if (items != 0)
1291         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPopClientAttrib()");
1292     {
1293 #line 919 "OpenGL.xs"
1294                 glPopClientAttrib();
1295 #line 1296 "OpenGL.c"
1296     }
1297     XSRETURN_EMPTY;
1298 }
1299
1300 XS(XS_SDL__OpenGL_glMatrixMode); /* prototype to pass -Wmissing-prototypes */
1301 XS(XS_SDL__OpenGL_glMatrixMode)
1302 {
1303     dXSARGS;
1304     if (items != 1)
1305         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glMatrixMode(mode)");
1306     {
1307         GLenum  mode = (GLenum)SvIV(ST(0));
1308 #line 925 "OpenGL.xs"
1309                 glMatrixMode(mode);
1310 #line 1311 "OpenGL.c"
1311     }
1312     XSRETURN_EMPTY;
1313 }
1314
1315 XS(XS_SDL__OpenGL_glLoadIdentity); /* prototype to pass -Wmissing-prototypes */
1316 XS(XS_SDL__OpenGL_glLoadIdentity)
1317 {
1318     dXSARGS;
1319     if (items != 0)
1320         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glLoadIdentity()");
1321     {
1322 #line 930 "OpenGL.xs"
1323                 glLoadIdentity();
1324 #line 1325 "OpenGL.c"
1325     }
1326     XSRETURN_EMPTY;
1327 }
1328
1329 XS(XS_SDL__OpenGL_glLoadMatrix); /* prototype to pass -Wmissing-prototypes */
1330 XS(XS_SDL__OpenGL_glLoadMatrix)
1331 {
1332     dXSARGS;
1333     {
1334 #line 935 "OpenGL.xs"
1335                 int i;
1336                 double mat[16];
1337                 for ( i = 0; i < 16; i++ ) {
1338                         mat[i] = (i < items  && SvNOK(ST(i)) ? SvNV(ST(i)) : 0.0 );
1339                 }
1340                 glLoadMatrixd(mat);
1341 #line 1342 "OpenGL.c"
1342     }
1343     XSRETURN_EMPTY;
1344 }
1345
1346 XS(XS_SDL__OpenGL_glMultMatrix); /* prototype to pass -Wmissing-prototypes */
1347 XS(XS_SDL__OpenGL_glMultMatrix)
1348 {
1349     dXSARGS;
1350     {
1351 #line 945 "OpenGL.xs"
1352                 int i;
1353                 double mat[16];
1354                 for ( i = 0; i < 16; i++ ) {
1355                         mat[i] = (i < items  && SvNOK(ST(i)) ? SvNV(ST(i)) : 0.0 );
1356                 }
1357                 glMultMatrixd(mat);
1358 #line 1359 "OpenGL.c"
1359     }
1360     XSRETURN_EMPTY;
1361 }
1362
1363 XS(XS_SDL__OpenGL_glTranslate); /* prototype to pass -Wmissing-prototypes */
1364 XS(XS_SDL__OpenGL_glTranslate)
1365 {
1366     dXSARGS;
1367     if (items != 3)
1368         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTranslate(x, y, z)");
1369     {
1370         double  x = (double)SvNV(ST(0));
1371         double  y = (double)SvNV(ST(1));
1372         double  z = (double)SvNV(ST(2));
1373 #line 958 "OpenGL.xs"
1374                 glTranslated(x,y,z);
1375 #line 1376 "OpenGL.c"
1376     }
1377     XSRETURN_EMPTY;
1378 }
1379
1380 XS(XS_SDL__OpenGL_glRotate); /* prototype to pass -Wmissing-prototypes */
1381 XS(XS_SDL__OpenGL_glRotate)
1382 {
1383     dXSARGS;
1384     if (items != 4)
1385         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glRotate(angle, x, y, z)");
1386     {
1387         double  angle = (double)SvNV(ST(0));
1388         double  x = (double)SvNV(ST(1));
1389         double  y = (double)SvNV(ST(2));
1390         double  z = (double)SvNV(ST(3));
1391 #line 967 "OpenGL.xs"
1392                 glRotated(angle,x,y,z);
1393 #line 1394 "OpenGL.c"
1394     }
1395     XSRETURN_EMPTY;
1396 }
1397
1398 XS(XS_SDL__OpenGL_glScale); /* prototype to pass -Wmissing-prototypes */
1399 XS(XS_SDL__OpenGL_glScale)
1400 {
1401     dXSARGS;
1402     if (items != 3)
1403         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glScale(x, y, z)");
1404     {
1405         double  x = (double)SvNV(ST(0));
1406         double  y = (double)SvNV(ST(1));
1407         double  z = (double)SvNV(ST(2));
1408 #line 975 "OpenGL.xs"
1409                 glScaled(x,y,z);
1410 #line 1411 "OpenGL.c"
1411     }
1412     XSRETURN_EMPTY;
1413 }
1414
1415 XS(XS_SDL__OpenGL_glFrustum); /* prototype to pass -Wmissing-prototypes */
1416 XS(XS_SDL__OpenGL_glFrustum)
1417 {
1418     dXSARGS;
1419     if (items != 6)
1420         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glFrustum(left, right, bottom, top, n, f)");
1421     {
1422         double  left = (double)SvNV(ST(0));
1423         double  right = (double)SvNV(ST(1));
1424         double  bottom = (double)SvNV(ST(2));
1425         double  top = (double)SvNV(ST(3));
1426         double  n = (double)SvNV(ST(4));
1427         double  f = (double)SvNV(ST(5));
1428 #line 986 "OpenGL.xs"
1429                 glFrustum(left,right,bottom,top,n,f);
1430 #line 1431 "OpenGL.c"
1431     }
1432     XSRETURN_EMPTY;
1433 }
1434
1435 XS(XS_SDL__OpenGL_glOrtho); /* prototype to pass -Wmissing-prototypes */
1436 XS(XS_SDL__OpenGL_glOrtho)
1437 {
1438     dXSARGS;
1439     if (items != 6)
1440         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glOrtho(left, right, bottom, top, n, f)");
1441     {
1442         double  left = (double)SvNV(ST(0));
1443         double  right = (double)SvNV(ST(1));
1444         double  bottom = (double)SvNV(ST(2));
1445         double  top = (double)SvNV(ST(3));
1446         double  n = (double)SvNV(ST(4));
1447         double  f = (double)SvNV(ST(5));
1448 #line 997 "OpenGL.xs"
1449                 glOrtho(left,right,bottom,top,n,f);
1450 #line 1451 "OpenGL.c"
1451     }
1452     XSRETURN_EMPTY;
1453 }
1454
1455 XS(XS_SDL__OpenGL_glViewport); /* prototype to pass -Wmissing-prototypes */
1456 XS(XS_SDL__OpenGL_glViewport)
1457 {
1458     dXSARGS;
1459     if (items != 4)
1460         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glViewport(x, y, width, height)");
1461     {
1462         Sint32  x = (Sint32)SvIV(ST(0));
1463         Sint32  y = (Sint32)SvIV(ST(1));
1464         Uint32  width = (Uint32)SvUV(ST(2));
1465         Uint32  height = (Uint32)SvUV(ST(3));
1466 #line 1006 "OpenGL.xs"
1467                 glViewport(x,y,width,height);
1468 #line 1469 "OpenGL.c"
1469     }
1470     XSRETURN_EMPTY;
1471 }
1472
1473 XS(XS_SDL__OpenGL_glDepthRange); /* prototype to pass -Wmissing-prototypes */
1474 XS(XS_SDL__OpenGL_glDepthRange)
1475 {
1476     dXSARGS;
1477     if (items != 2)
1478         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDepthRange(n, f)");
1479     {
1480         double  n = (double)SvNV(ST(0));
1481         double  f = (double)SvNV(ST(1));
1482 #line 1013 "OpenGL.xs"
1483                 glDepthRange(n,f);
1484 #line 1485 "OpenGL.c"
1485     }
1486     XSRETURN_EMPTY;
1487 }
1488
1489 XS(XS_SDL__OpenGL_glPushMatrix); /* prototype to pass -Wmissing-prototypes */
1490 XS(XS_SDL__OpenGL_glPushMatrix)
1491 {
1492     dXSARGS;
1493     if (items != 0)
1494         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPushMatrix()");
1495     {
1496 #line 1018 "OpenGL.xs"
1497                 glPushMatrix();
1498 #line 1499 "OpenGL.c"
1499     }
1500     XSRETURN_EMPTY;
1501 }
1502
1503 XS(XS_SDL__OpenGL_glPopMatrix); /* prototype to pass -Wmissing-prototypes */
1504 XS(XS_SDL__OpenGL_glPopMatrix)
1505 {
1506     dXSARGS;
1507     if (items != 0)
1508         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPopMatrix()");
1509     {
1510 #line 1023 "OpenGL.xs"
1511                 glPopMatrix();
1512 #line 1513 "OpenGL.c"
1513     }
1514     XSRETURN_EMPTY;
1515 }
1516
1517 XS(XS_SDL__OpenGL_glClipPlane); /* prototype to pass -Wmissing-prototypes */
1518 XS(XS_SDL__OpenGL_glClipPlane)
1519 {
1520     dXSARGS;
1521     if (items < 1)
1522         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glClipPlane(plane, ...)");
1523     {
1524         GLenum  plane = (GLenum)SvIV(ST(0));
1525 #line 1029 "OpenGL.xs"
1526                 double v[4];
1527                 int i;
1528                 for (i = 0; i < 4; i++ ) {
1529                         v[i] = (i+1 < items && SvNOK(ST(i+1))) ? SvNV(ST(i+1)) : 0.0;
1530                 }
1531                 glClipPlane(plane,v);
1532 #line 1533 "OpenGL.c"
1533     }
1534     XSRETURN_EMPTY;
1535 }
1536
1537 XS(XS_SDL__OpenGL_glColor); /* prototype to pass -Wmissing-prototypes */
1538 XS(XS_SDL__OpenGL_glColor)
1539 {
1540     dXSARGS;
1541     if (items < 3)
1542         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glColor(r, g, b, ...)");
1543     {
1544         double  r = (double)SvNV(ST(0));
1545         double  g = (double)SvNV(ST(1));
1546         double  b = (double)SvNV(ST(2));
1547 #line 1042 "OpenGL.xs"
1548                 if ( items == 4 ) {
1549                         double a;
1550                         a = SvNV(ST(3));
1551                         glColor4d(r,g,b,a);
1552                 } else {
1553                         glColor3d(r,g,b);
1554                 }
1555 #line 1556 "OpenGL.c"
1556     }
1557     XSRETURN_EMPTY;
1558 }
1559
1560 XS(XS_SDL__OpenGL_glIndex); /* prototype to pass -Wmissing-prototypes */
1561 XS(XS_SDL__OpenGL_glIndex)
1562 {
1563     dXSARGS;
1564     if (items != 1)
1565         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glIndex(c)");
1566     {
1567         Uint32  c = (Uint32)SvUV(ST(0));
1568 #line 1054 "OpenGL.xs"
1569                 glIndexi(c);
1570 #line 1571 "OpenGL.c"
1571     }
1572     XSRETURN_EMPTY;
1573 }
1574
1575 XS(XS_SDL__OpenGL_glShadeModel); /* prototype to pass -Wmissing-prototypes */
1576 XS(XS_SDL__OpenGL_glShadeModel)
1577 {
1578     dXSARGS;
1579     if (items != 1)
1580         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glShadeModel(mode)");
1581     {
1582         GLenum  mode = (GLenum)SvIV(ST(0));
1583 #line 1060 "OpenGL.xs"
1584                 glShadeModel(mode);
1585 #line 1586 "OpenGL.c"
1586     }
1587     XSRETURN_EMPTY;
1588 }
1589
1590 XS(XS_SDL__OpenGL_glLight); /* prototype to pass -Wmissing-prototypes */
1591 XS(XS_SDL__OpenGL_glLight)
1592 {
1593     dXSARGS;
1594     if (items < 2)
1595         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glLight(light, name, ...)");
1596     {
1597         GLenum  light = (GLenum)SvIV(ST(0));
1598         GLenum  name = (GLenum)SvIV(ST(1));
1599 #line 1067 "OpenGL.xs"
1600                 int i;
1601                 if ( items == 6 ) {
1602                         float v[4];
1603                         for ( i = 0; i < 4; i++ ) {
1604                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1605                         }
1606                         glLightfv(light,name,v);
1607                 } else if ( items == 5 ) {
1608                         float v[3];
1609                         for ( i = 0; i < 3; i++ ) {
1610                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1611                         }
1612                         glLightfv(light,name,v);
1613                 } else if ( items == 3 ) {
1614                         float v;
1615                         v = SvNV(ST(2));
1616                         glLightf(light,name,v);
1617                 } else {
1618                         Perl_croak(aTHX_ "SDL::OpenGL::Light invalid arguments");
1619                 }
1620 #line 1621 "OpenGL.c"
1621     }
1622     XSRETURN_EMPTY;
1623 }
1624
1625 XS(XS_SDL__OpenGL_glLightModel); /* prototype to pass -Wmissing-prototypes */
1626 XS(XS_SDL__OpenGL_glLightModel)
1627 {
1628     dXSARGS;
1629     if (items < 1)
1630         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glLightModel(pname, ...)");
1631     {
1632         GLenum  pname = (GLenum)SvIV(ST(0));
1633 #line 1092 "OpenGL.xs"
1634                 GLfloat vec[4];
1635                 if ( pname == GL_LIGHT_MODEL_LOCAL_VIEWER ||
1636                         pname == GL_LIGHT_MODEL_TWO_SIDE ||
1637                         pname == GL_LIGHT_MODEL_COLOR_CONTROL ) {
1638                         glLightModelf(pname,SvNV(ST(1)));
1639                 } else if ( pname == GL_LIGHT_MODEL_AMBIENT) {
1640                         vec[0] = SvNV(ST(1));
1641                         vec[1] = SvNV(ST(2));
1642                         vec[2] = SvNV(ST(3));
1643                         vec[3] = SvNV(ST(4));
1644                         glLightModelfv(pname,vec);
1645                 } else {
1646                         Perl_croak(aTHX_ "SDL::OpenGL::glLightModel unknown model %d",pname);
1647                 }
1648 #line 1649 "OpenGL.c"
1649     }
1650     XSRETURN_EMPTY;
1651 }
1652
1653 XS(XS_SDL__OpenGL_glMaterial); /* prototype to pass -Wmissing-prototypes */
1654 XS(XS_SDL__OpenGL_glMaterial)
1655 {
1656     dXSARGS;
1657     if (items < 2)
1658         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glMaterial(face, name, ...)");
1659     {
1660         GLenum  face = (GLenum)SvIV(ST(0));
1661         GLenum  name = (GLenum)SvIV(ST(1));
1662 #line 1112 "OpenGL.xs"
1663                 int i;
1664                 if ( items == 6 ) {
1665                         float v[4];
1666                         for ( i = 0; i < 4; i++ ) {
1667                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1668                         }
1669                         glMaterialfv(face,name,v);
1670                 } else if ( items == 5 ) {
1671                         float v[3];
1672                         for ( i = 0; i < 4; i++ ) {
1673                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1674                         }
1675                         glMaterialfv(face,name,v);
1676                 } else if ( items == 3 ) {
1677                         float v;
1678                         v = SvNV(ST(2));
1679                         glMaterialf(face,name,v);
1680                 } else {
1681                         Perl_croak(aTHX_ "SDL::OpenGL::Material invalid arguments");
1682                 }
1683 #line 1684 "OpenGL.c"
1684     }
1685     XSRETURN_EMPTY;
1686 }
1687
1688 XS(XS_SDL__OpenGL_glColorMaterial); /* prototype to pass -Wmissing-prototypes */
1689 XS(XS_SDL__OpenGL_glColorMaterial)
1690 {
1691     dXSARGS;
1692     if (items != 2)
1693         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glColorMaterial(face, mode)");
1694     {
1695         GLenum  face = (GLenum)SvIV(ST(0));
1696         GLenum  mode = (GLenum)SvIV(ST(1));
1697 #line 1138 "OpenGL.xs"
1698                 glColorMaterial(face,mode);
1699 #line 1700 "OpenGL.c"
1700     }
1701     XSRETURN_EMPTY;
1702 }
1703
1704 XS(XS_SDL__OpenGL_glBlendFunc); /* prototype to pass -Wmissing-prototypes */
1705 XS(XS_SDL__OpenGL_glBlendFunc)
1706 {
1707     dXSARGS;
1708     if (items != 2)
1709         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glBlendFunc(sfactor, dfactor)");
1710     {
1711         GLenum  sfactor = (GLenum)SvIV(ST(0));
1712         GLenum  dfactor = (GLenum)SvIV(ST(1));
1713 #line 1145 "OpenGL.xs"
1714                 glBlendFunc(sfactor,dfactor);
1715 #line 1716 "OpenGL.c"
1716     }
1717     XSRETURN_EMPTY;
1718 }
1719
1720 XS(XS_SDL__OpenGL_glHint); /* prototype to pass -Wmissing-prototypes */
1721 XS(XS_SDL__OpenGL_glHint)
1722 {
1723     dXSARGS;
1724     if (items != 2)
1725         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glHint(target, hint)");
1726     {
1727         GLenum  target = (GLenum)SvIV(ST(0));
1728         GLenum  hint = (GLenum)SvIV(ST(1));
1729 #line 1153 "OpenGL.xs"
1730                 glHint(target,hint);
1731 #line 1732 "OpenGL.c"
1732     }
1733     XSRETURN_EMPTY;
1734 }
1735
1736 XS(XS_SDL__OpenGL_glFog); /* prototype to pass -Wmissing-prototypes */
1737 XS(XS_SDL__OpenGL_glFog)
1738 {
1739     dXSARGS;
1740     if (items < 1)
1741         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glFog(name, ...)");
1742     {
1743         GLenum  name = (GLenum)SvIV(ST(0));
1744 #line 1159 "OpenGL.xs"
1745                 if ( items == 5 )  {
1746                         float v[4];
1747                         v[0] = SvNV(ST(1));
1748                         v[1] = SvNV(ST(2));
1749                         v[2] = SvNV(ST(3));
1750                         v[3] = SvNV(ST(4));
1751                         glFogfv(name,v);
1752                 } else if ( items == 2 ) {
1753                         float v;
1754                         v = SvNV(ST(1));
1755                         glFogf(name,v);
1756                 } else {
1757                         Perl_croak(aTHX_ "SDL::OpenGL::Material invalid arguments");
1758                 }
1759 #line 1760 "OpenGL.c"
1760     }
1761     XSRETURN_EMPTY;
1762 }
1763
1764 XS(XS_SDL__OpenGL_glPolygonOffset); /* prototype to pass -Wmissing-prototypes */
1765 XS(XS_SDL__OpenGL_glPolygonOffset)
1766 {
1767     dXSARGS;
1768     if (items != 2)
1769         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPolygonOffset(factor, units)");
1770     {
1771         double  factor = (double)SvNV(ST(0));
1772         double  units = (double)SvNV(ST(1));
1773 #line 1179 "OpenGL.xs"
1774                 glPolygonOffset(factor,units);
1775 #line 1776 "OpenGL.c"
1776     }
1777     XSRETURN_EMPTY;
1778 }
1779
1780 XS(XS_SDL__OpenGL_glGenLists); /* prototype to pass -Wmissing-prototypes */
1781 XS(XS_SDL__OpenGL_glGenLists)
1782 {
1783     dXSARGS;
1784     if (items != 1)
1785         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glGenLists(range)");
1786     {
1787         Uint32  range = (Uint32)SvUV(ST(0));
1788         Uint32  RETVAL;
1789         dXSTARG;
1790 #line 1185 "OpenGL.xs"
1791                 RETVAL = glGenLists(range);
1792 #line 1793 "OpenGL.c"
1793         XSprePUSH; PUSHu((UV)RETVAL);
1794     }
1795     XSRETURN(1);
1796 }
1797
1798 XS(XS_SDL__OpenGL_glNewList); /* prototype to pass -Wmissing-prototypes */
1799 XS(XS_SDL__OpenGL_glNewList)
1800 {
1801     dXSARGS;
1802     if (items != 2)
1803         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glNewList(list, mode)");
1804     {
1805         Uint32  list = (Uint32)SvUV(ST(0));
1806         GLenum  mode = (GLenum)SvIV(ST(1));
1807 #line 1194 "OpenGL.xs"
1808                 glNewList(list,mode);
1809 #line 1810 "OpenGL.c"
1810     }
1811     XSRETURN_EMPTY;
1812 }
1813
1814 XS(XS_SDL__OpenGL_glEndList); /* prototype to pass -Wmissing-prototypes */
1815 XS(XS_SDL__OpenGL_glEndList)
1816 {
1817     dXSARGS;
1818     if (items != 0)
1819         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glEndList()");
1820     {
1821 #line 1199 "OpenGL.xs"
1822                 glEndList();
1823 #line 1824 "OpenGL.c"
1824     }
1825     XSRETURN_EMPTY;
1826 }
1827
1828 XS(XS_SDL__OpenGL_glDeleteLists); /* prototype to pass -Wmissing-prototypes */
1829 XS(XS_SDL__OpenGL_glDeleteLists)
1830 {
1831     dXSARGS;
1832     if (items != 2)
1833         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDeleteLists(base, count)");
1834     {
1835         Uint32  base = (Uint32)SvUV(ST(0));
1836         Uint32  count = (Uint32)SvUV(ST(1));
1837 #line 1206 "OpenGL.xs"
1838                 glDeleteLists(base, count);
1839 #line 1840 "OpenGL.c"
1840     }
1841     XSRETURN_EMPTY;
1842 }
1843
1844 XS(XS_SDL__OpenGL_glCallList); /* prototype to pass -Wmissing-prototypes */
1845 XS(XS_SDL__OpenGL_glCallList)
1846 {
1847     dXSARGS;
1848     if (items != 1)
1849         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCallList(list)");
1850     {
1851         Uint32  list = (Uint32)SvUV(ST(0));
1852 #line 1212 "OpenGL.xs"
1853                 glCallList(list);
1854 #line 1855 "OpenGL.c"
1855     }
1856     XSRETURN_EMPTY;
1857 }
1858
1859 XS(XS_SDL__OpenGL_glIsList); /* prototype to pass -Wmissing-prototypes */
1860 XS(XS_SDL__OpenGL_glIsList)
1861 {
1862     dXSARGS;
1863     if (items != 1)
1864         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glIsList(list)");
1865     {
1866         Uint32  list = (Uint32)SvUV(ST(0));
1867         Uint32  RETVAL;
1868         dXSTARG;
1869 #line 1218 "OpenGL.xs"
1870                 RETVAL = glIsList(list);
1871 #line 1872 "OpenGL.c"
1872         XSprePUSH; PUSHu((UV)RETVAL);
1873     }
1874     XSRETURN(1);
1875 }
1876
1877 XS(XS_SDL__OpenGL_glListBase); /* prototype to pass -Wmissing-prototypes */
1878 XS(XS_SDL__OpenGL_glListBase)
1879 {
1880     dXSARGS;
1881     if (items != 1)
1882         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glListBase(base)");
1883     {
1884         Uint32  base = (Uint32)SvUV(ST(0));
1885 #line 1226 "OpenGL.xs"
1886                 glListBase(base);
1887 #line 1888 "OpenGL.c"
1888     }
1889     XSRETURN_EMPTY;
1890 }
1891
1892 XS(XS_SDL__OpenGL_glCallLists); /* prototype to pass -Wmissing-prototypes */
1893 XS(XS_SDL__OpenGL_glCallLists)
1894 {
1895     dXSARGS;
1896     {
1897 #line 1231 "OpenGL.xs"
1898                 int *i, j;
1899                 if ( items > 0 ) {
1900                         i = (int*)safemalloc(sizeof(int)* (items));
1901                         for ( j = 0; j < items; j++ ) {
1902                                 i[j] = SvIV(ST(j));
1903                         }
1904                 } else {
1905                         Perl_croak(aTHX_ "usage: SDL::OpenGL::CallLists(type,...)");
1906                 }
1907                 glCallLists(items, GL_INT, i);
1908                 safefree(i);
1909 #line 1910 "OpenGL.c"
1910     }
1911     XSRETURN_EMPTY;
1912 }
1913
1914 XS(XS_SDL__OpenGL_glCallListsString); /* prototype to pass -Wmissing-prototypes */
1915 XS(XS_SDL__OpenGL_glCallListsString)
1916 {
1917     dXSARGS;
1918     if (items != 1)
1919         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCallListsString(string)");
1920     {
1921         SV*     string = ST(0);
1922 #line 1247 "OpenGL.xs"
1923                 char *str;
1924                 STRLEN len;
1925                 str = SvPV(string,len);
1926                 glCallLists(len,GL_BYTE,str);
1927 #line 1928 "OpenGL.c"
1928     }
1929     XSRETURN_EMPTY;
1930 }
1931
1932 XS(XS_SDL__OpenGL_glRasterPos); /* prototype to pass -Wmissing-prototypes */
1933 XS(XS_SDL__OpenGL_glRasterPos)
1934 {
1935     dXSARGS;
1936     if (items < 3)
1937         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glRasterPos(x, y, z, ...)");
1938     {
1939         double  x = (double)SvNV(ST(0));
1940         double  y = (double)SvNV(ST(1));
1941         double  z = (double)SvNV(ST(2));
1942 #line 1258 "OpenGL.xs"
1943                 if ( items == 4 ) {
1944                         double w = SvNV(ST(3));
1945                         glRasterPos4d(x,y,z,w);
1946                 } else {
1947                         glRasterPos3d(x,y,z);
1948                 }
1949 #line 1950 "OpenGL.c"
1950     }
1951     XSRETURN_EMPTY;
1952 }
1953
1954 XS(XS_SDL__OpenGL_glBitmap); /* prototype to pass -Wmissing-prototypes */
1955 XS(XS_SDL__OpenGL_glBitmap)
1956 {
1957     dXSARGS;
1958     if (items != 7)
1959         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glBitmap(width, height, x1, y1, x2, y2, data)");
1960     {
1961         Uint32  width = (Uint32)SvUV(ST(0));
1962         Uint32  height = (Uint32)SvUV(ST(1));
1963         double  x1 = (double)SvNV(ST(2));
1964         double  y1 = (double)SvNV(ST(3));
1965         double  x2 = (double)SvNV(ST(4));
1966         double  y2 = (double)SvNV(ST(5));
1967         char *  data = (char *)SvPV_nolen(ST(6));
1968 #line 1275 "OpenGL.xs"
1969                 glBitmap(width,height,x1,y1,x2,y2,data);
1970 #line 1971 "OpenGL.c"
1971     }
1972     XSRETURN_EMPTY;
1973 }
1974
1975 XS(XS_SDL__OpenGL_glDrawPixels); /* prototype to pass -Wmissing-prototypes */
1976 XS(XS_SDL__OpenGL_glDrawPixels)
1977 {
1978     dXSARGS;
1979     if (items != 5)
1980         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDrawPixels(width, height, format, type, pixels)");
1981     {
1982         Uint32  width = (Uint32)SvUV(ST(0));
1983         Uint32  height = (Uint32)SvUV(ST(1));
1984         GLenum  format = (GLenum)SvIV(ST(2));
1985         GLenum  type = (GLenum)SvIV(ST(3));
1986         char *  pixels = (char *)SvPV_nolen(ST(4));
1987 #line 1285 "OpenGL.xs"
1988                 glDrawPixels(width,height,format,type,pixels);
1989 #line 1990 "OpenGL.c"
1990     }
1991     XSRETURN_EMPTY;
1992 }
1993
1994 XS(XS_SDL__OpenGL_glReadPixels); /* prototype to pass -Wmissing-prototypes */
1995 XS(XS_SDL__OpenGL_glReadPixels)
1996 {
1997     dXSARGS;
1998     if (items != 6)
1999         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glReadPixels(x, y, width, height, format, type)");
2000     {
2001         Uint32  x = (Uint32)SvUV(ST(0));
2002         Uint32  y = (Uint32)SvUV(ST(1));
2003         Uint32  height = (Uint32)SvUV(ST(3));
2004         Uint32  width = (Uint32)SvUV(ST(2));
2005         GLenum  format = (GLenum)SvIV(ST(4));
2006         GLenum  type = (GLenum)SvIV(ST(5));
2007         SV *    RETVAL;
2008 #line 1297 "OpenGL.xs"
2009                 int len, size;
2010                 char *buf;
2011                 size = 1;       /* ALPHA, BLUE, GREEN or RED */
2012                 if (format == GL_BGR || format == GL_RGB)
2013                         size = 3;
2014                 if (format == GL_BGRA || format == GL_RGBA)
2015                         size = 4;
2016                 len = height * width * size;            /* in bytes */
2017                 RETVAL = newSV(len);                    /* alloc len+1 bytes */
2018                 SvPOK_on(RETVAL);                       /* make an PV */
2019                 buf = SvPVX(RETVAL);                    /* get ptr to buffer */
2020                 glReadPixels(x,y,width,height,format,type,buf);
2021                 SvCUR_set(RETVAL, len);                 /* set real length */
2022 #line 2023 "OpenGL.c"
2023         ST(0) = RETVAL;
2024         sv_2mortal(ST(0));
2025     }
2026     XSRETURN(1);
2027 }
2028
2029 XS(XS_SDL__OpenGL_glReadPixel); /* prototype to pass -Wmissing-prototypes */
2030 XS(XS_SDL__OpenGL_glReadPixel)
2031 {
2032     dXSARGS;
2033     if (items != 2)
2034         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glReadPixel(x, y)");
2035     {
2036         Uint32  x = (Uint32)SvUV(ST(0));
2037         Uint32  y = (Uint32)SvUV(ST(1));
2038         AV *    RETVAL;
2039 #line 1318 "OpenGL.xs"
2040                 int rgba[4];    /* r,g,b,a */
2041                 int i;
2042                 glReadPixels(x,y,1,1,GL_RGBA,GL_UNSIGNED_INT,rgba);
2043                 RETVAL = newAV();
2044                 for ( i = 0; i < 4; i++ ) {
2045                         av_push(RETVAL,newSViv(rgba[i]));
2046                 }
2047 #line 2048 "OpenGL.c"
2048         ST(0) = newRV((SV*)RETVAL);
2049         sv_2mortal(ST(0));
2050     }
2051     XSRETURN(1);
2052 }
2053
2054 XS(XS_SDL__OpenGL_glCopyPixels); /* prototype to pass -Wmissing-prototypes */
2055 XS(XS_SDL__OpenGL_glCopyPixels)
2056 {
2057     dXSARGS;
2058     if (items != 5)
2059         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCopyPixels(x, y, width, height, buffer)");
2060     {
2061         Sint32  x = (Sint32)SvIV(ST(0));
2062         Sint32  y = (Sint32)SvIV(ST(1));
2063         Uint32  width = (Uint32)SvUV(ST(2));
2064         Uint32  height = (Uint32)SvUV(ST(3));
2065         GLenum  buffer = (GLenum)SvIV(ST(4));
2066 #line 1336 "OpenGL.xs"
2067                 glCopyPixels(x,y,width,height,buffer);
2068 #line 2069 "OpenGL.c"
2069     }
2070     XSRETURN_EMPTY;
2071 }
2072
2073 XS(XS_SDL__OpenGL_glPixelStore); /* prototype to pass -Wmissing-prototypes */
2074 XS(XS_SDL__OpenGL_glPixelStore)
2075 {
2076     dXSARGS;
2077     if (items != 2)
2078         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPixelStore(name, param)");
2079     {
2080         Sint32  name = (Sint32)SvIV(ST(0));
2081         double  param = (double)SvNV(ST(1));
2082 #line 1343 "OpenGL.xs"
2083                 glPixelStorei(name,param);
2084 #line 2085 "OpenGL.c"
2085     }
2086     XSRETURN_EMPTY;
2087 }
2088
2089 XS(XS_SDL__OpenGL_glPixelTransfer); /* prototype to pass -Wmissing-prototypes */
2090 XS(XS_SDL__OpenGL_glPixelTransfer)
2091 {
2092     dXSARGS;
2093     if (items < 1)
2094         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPixelTransfer(name, ...)");
2095     {
2096         GLenum  name = (GLenum)SvIV(ST(0));
2097 #line 1349 "OpenGL.xs"
2098                 switch ( name ) {
2099                         case GL_MAP_COLOR:
2100                         case GL_MAP_STENCIL:
2101                         case GL_INDEX_SHIFT:
2102                         case GL_INDEX_OFFSET:
2103                                 glPixelTransferi(name,SvIV(ST(1)));
2104                                 break;
2105                         default:
2106                                 glPixelTransferf(name,SvNV(ST(1)));
2107                                 break;
2108                 }
2109 #line 2110 "OpenGL.c"
2110     }
2111     XSRETURN_EMPTY;
2112 }
2113
2114 XS(XS_SDL__OpenGL_glPixelMap); /* prototype to pass -Wmissing-prototypes */
2115 XS(XS_SDL__OpenGL_glPixelMap)
2116 {
2117     dXSARGS;
2118     if (items != 4)
2119         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPixelMap(type, map, mapsize, values)");
2120     {
2121         GLenum  type = (GLenum)SvIV(ST(0));
2122         GLenum  map = (GLenum)SvIV(ST(1));
2123         Sint32  mapsize = (Sint32)SvIV(ST(2));
2124         char *  values = (char *)SvPV_nolen(ST(3));
2125 #line 1368 "OpenGL.xs"
2126                 switch (type) {
2127                         case GL_UNSIGNED_INT:
2128                                 glPixelMapuiv(map,mapsize,(GLint*)values);
2129                                 break;
2130                         case GL_UNSIGNED_SHORT:
2131                                 glPixelMapusv(map,mapsize,(GLushort*)values);
2132                                 break;
2133                         case GL_FLOAT:
2134                                 glPixelMapfv(map,mapsize,(GLfloat*)values);
2135                                 break;
2136                 }
2137 #line 2138 "OpenGL.c"
2138     }
2139     XSRETURN_EMPTY;
2140 }
2141
2142 XS(XS_SDL__OpenGL_glPixelZoom); /* prototype to pass -Wmissing-prototypes */
2143 XS(XS_SDL__OpenGL_glPixelZoom)
2144 {
2145     dXSARGS;
2146     if (items != 2)
2147         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPixelZoom(zoomx, zoomy)");
2148     {
2149         double  zoomx = (double)SvNV(ST(0));
2150         double  zoomy = (double)SvNV(ST(1));
2151 #line 1385 "OpenGL.xs"
2152                 glPixelZoom(zoomx,zoomy);
2153 #line 2154 "OpenGL.c"
2154     }
2155     XSRETURN_EMPTY;
2156 }
2157
2158 #ifdef GL_VERSION_1_3
2159 #define XSubPPtmpAAAB 1
2160
2161 XS(XS_SDL__OpenGL_glColorTable); /* prototype to pass -Wmissing-prototypes */
2162 XS(XS_SDL__OpenGL_glColorTable)
2163 {
2164     dXSARGS;
2165     if (items != 6)
2166         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glColorTable(target, internalFormat, width, format, type, data)");
2167     {
2168         GLenum  target = (GLenum)SvIV(ST(0));
2169         GLenum  internalFormat = (GLenum)SvIV(ST(1));
2170         Uint32  width = (Uint32)SvUV(ST(2));
2171         GLenum  format = (GLenum)SvIV(ST(3));
2172         GLenum  type = (GLenum)SvIV(ST(4));
2173         char *  data = (char *)SvPV_nolen(ST(5));
2174 #line 1398 "OpenGL.xs"
2175                 glColorTable(target,internalFormat,width,format,type,data);
2176 #line 2177 "OpenGL.c"
2177     }
2178     XSRETURN_EMPTY;
2179 }
2180
2181 XS(XS_SDL__OpenGL_glColorTableParameter); /* prototype to pass -Wmissing-prototypes */
2182 XS(XS_SDL__OpenGL_glColorTableParameter)
2183 {
2184     dXSARGS;
2185     if (items != 6)
2186         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glColorTableParameter(target, name, r, g, b, a)");
2187     {
2188         GLenum  target = (GLenum)SvIV(ST(0));
2189         GLenum  name = (GLenum)SvIV(ST(1));
2190         double  r = (double)SvNV(ST(2));
2191         double  g = (double)SvNV(ST(3));
2192         double  b = (double)SvNV(ST(4));
2193         double  a = (double)SvNV(ST(5));
2194 #line 1409 "OpenGL.xs"
2195                 GLfloat vec[4];
2196                 vec[0] = r;
2197                 vec[1] = g;
2198                 vec[2] = b;
2199                 vec[3] = a;
2200                 glColorTableParameterfv(target,name,vec);
2201 #line 2202 "OpenGL.c"
2202     }
2203     XSRETURN_EMPTY;
2204 }
2205
2206 XS(XS_SDL__OpenGL_glCopyColorTable); /* prototype to pass -Wmissing-prototypes */
2207 XS(XS_SDL__OpenGL_glCopyColorTable)
2208 {
2209     dXSARGS;
2210     if (items != 5)
2211         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCopyColorTable(target, internalFormat, x, y, width)");
2212     {
2213         GLenum  target = (GLenum)SvIV(ST(0));
2214         GLenum  internalFormat = (GLenum)SvIV(ST(1));
2215         Sint32  x = (Sint32)SvIV(ST(2));
2216         Sint32  y = (Sint32)SvIV(ST(3));
2217         Uint32  width = (Uint32)SvUV(ST(4));
2218 #line 1424 "OpenGL.xs"
2219                 glCopyColorTable(target,internalFormat,x,y,width);
2220 #line 2221 "OpenGL.c"
2221     }
2222     XSRETURN_EMPTY;
2223 }
2224
2225 XS(XS_SDL__OpenGL_glColorSubTable); /* prototype to pass -Wmissing-prototypes */
2226 XS(XS_SDL__OpenGL_glColorSubTable)
2227 {
2228     dXSARGS;
2229     if (items != 6)
2230         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glColorSubTable(target, start, count, format, type, data)");
2231     {
2232         Uint32  target = (Uint32)SvUV(ST(0));
2233         Uint32  start = (Uint32)SvUV(ST(1));
2234         Uint32  count = (Uint32)SvUV(ST(2));
2235         Uint32  format = (Uint32)SvUV(ST(3));
2236         Uint32  type = (Uint32)SvUV(ST(4));
2237         char *  data = (char *)SvPV_nolen(ST(5));
2238 #line 1435 "OpenGL.xs"
2239                 glColorSubTable(target,start,count,format,type,data);
2240 #line 2241 "OpenGL.c"
2241     }
2242     XSRETURN_EMPTY;
2243 }
2244
2245 XS(XS_SDL__OpenGL_glCopyColorSubTable); /* prototype to pass -Wmissing-prototypes */
2246 XS(XS_SDL__OpenGL_glCopyColorSubTable)
2247 {
2248     dXSARGS;
2249     if (items != 5)
2250         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCopyColorSubTable(target, start, x, y, count)");
2251     {
2252         Uint32  target = (Uint32)SvUV(ST(0));
2253         Uint32  start = (Uint32)SvUV(ST(1));
2254         Sint32  x = (Sint32)SvIV(ST(2));
2255         Sint32  y = (Sint32)SvIV(ST(3));
2256         Uint32  count = (Uint32)SvUV(ST(4));
2257 #line 1445 "OpenGL.xs"
2258                 glCopyColorSubTable(target,start,x,y,count);
2259 #line 2260 "OpenGL.c"
2260     }
2261     XSRETURN_EMPTY;
2262 }
2263
2264 XS(XS_SDL__OpenGL_glConvolutionFilter2D); /* prototype to pass -Wmissing-prototypes */
2265 XS(XS_SDL__OpenGL_glConvolutionFilter2D)
2266 {
2267     dXSARGS;
2268     if (items != 7)
2269         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glConvolutionFilter2D(target, internalFormat, width, height, format, type, image)");
2270     {
2271         Uint32  target = (Uint32)SvUV(ST(0));
2272         Uint32  internalFormat = (Uint32)SvUV(ST(1));
2273         Uint32  width = (Uint32)SvUV(ST(2));
2274         Uint32  height = (Uint32)SvUV(ST(3));
2275         Uint32  format = (Uint32)SvUV(ST(4));
2276         Uint32  type = (Uint32)SvUV(ST(5));
2277         char *  image = (char *)SvPV_nolen(ST(6));
2278 #line 1457 "OpenGL.xs"
2279                 glConvolutionFilter2D(target,internalFormat,width,height,format,type,image);
2280 #line 2281 "OpenGL.c"
2281     }
2282     XSRETURN_EMPTY;
2283 }
2284
2285 XS(XS_SDL__OpenGL_glCopyConvolutionFilter2D); /* prototype to pass -Wmissing-prototypes */
2286 XS(XS_SDL__OpenGL_glCopyConvolutionFilter2D)
2287 {
2288     dXSARGS;
2289     if (items != 6)
2290         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCopyConvolutionFilter2D(target, internalFormat, x, y, width, height)");
2291     {
2292         Uint32  target = (Uint32)SvUV(ST(0));
2293         Uint32  internalFormat = (Uint32)SvUV(ST(1));
2294         Sint32  x = (Sint32)SvIV(ST(2));
2295         Sint32  y = (Sint32)SvIV(ST(3));
2296         Uint32  width = (Uint32)SvUV(ST(4));
2297         Uint32  height = (Uint32)SvUV(ST(5));
2298 #line 1468 "OpenGL.xs"
2299                 glCopyConvolutionFilter2D(target,internalFormat,x,y,width,height);
2300 #line 2301 "OpenGL.c"
2301     }
2302     XSRETURN_EMPTY;
2303 }
2304
2305 XS(XS_SDL__OpenGL_glSeparableFilter2D); /* prototype to pass -Wmissing-prototypes */
2306 XS(XS_SDL__OpenGL_glSeparableFilter2D)
2307 {
2308     dXSARGS;
2309     if (items != 8)
2310         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glSeparableFilter2D(target, internalFormat, width, height, format, type, row, column)");
2311     {
2312         Uint32  target = (Uint32)SvUV(ST(0));
2313         Uint32  internalFormat = (Uint32)SvUV(ST(1));
2314         Uint32  width = (Uint32)SvUV(ST(2));
2315         Uint32  height = (Uint32)SvUV(ST(3));
2316         Uint32  format = (Uint32)SvUV(ST(4));
2317         Uint32  type = (Uint32)SvUV(ST(5));
2318         char *  row = (char *)SvPV_nolen(ST(6));
2319         char *  column = (char *)SvPV_nolen(ST(7));
2320 #line 1481 "OpenGL.xs"
2321                 glSeparableFilter2D(target,internalFormat,width,height,format,type,row,column);
2322 #line 2323 "OpenGL.c"
2323     }
2324     XSRETURN_EMPTY;
2325 }
2326
2327 XS(XS_SDL__OpenGL_glConvolutionFilter1D); /* prototype to pass -Wmissing-prototypes */
2328 XS(XS_SDL__OpenGL_glConvolutionFilter1D)
2329 {
2330     dXSARGS;
2331     if (items != 6)
2332         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glConvolutionFilter1D(target, internalFormat, width, format, type, image)");
2333     {
2334         Uint32  target = (Uint32)SvUV(ST(0));
2335         Uint32  internalFormat = (Uint32)SvUV(ST(1));
2336         Uint32  width = (Uint32)SvUV(ST(2));
2337         Uint32  format = (Uint32)SvUV(ST(3));
2338         Uint32  type = (Uint32)SvUV(ST(4));
2339         char *  image = (char *)SvPV_nolen(ST(5));
2340 #line 1492 "OpenGL.xs"
2341                 glConvolutionFilter1D(target,internalFormat,width,format,type,image);
2342 #line 2343 "OpenGL.c"
2343     }
2344     XSRETURN_EMPTY;
2345 }
2346
2347 XS(XS_SDL__OpenGL_glCopyConvolutionFilter1D); /* prototype to pass -Wmissing-prototypes */
2348 XS(XS_SDL__OpenGL_glCopyConvolutionFilter1D)
2349 {
2350     dXSARGS;
2351     if (items != 5)
2352         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCopyConvolutionFilter1D(target, internalFormat, x, y, width)");
2353     {
2354         Uint32  target = (Uint32)SvUV(ST(0));
2355         Uint32  internalFormat = (Uint32)SvUV(ST(1));
2356         Sint32  x = (Sint32)SvIV(ST(2));
2357         Sint32  y = (Sint32)SvIV(ST(3));
2358         Uint32  width = (Uint32)SvUV(ST(4));
2359 #line 1502 "OpenGL.xs"
2360                 glCopyConvolutionFilter1D(target,internalFormat,x,y,width);
2361 #line 2362 "OpenGL.c"
2362     }
2363     XSRETURN_EMPTY;
2364 }
2365
2366 XS(XS_SDL__OpenGL_glConvolutionParameter); /* prototype to pass -Wmissing-prototypes */
2367 XS(XS_SDL__OpenGL_glConvolutionParameter)
2368 {
2369     dXSARGS;
2370     if (items < 2)
2371         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glConvolutionParameter(target, pname, ...)");
2372     {
2373         Uint32  target = (Uint32)SvUV(ST(0));
2374         Uint32  pname = (Uint32)SvUV(ST(1));
2375 #line 1509 "OpenGL.xs"
2376                 Uint32 pi;
2377                 GLfloat pv[4];
2378                 switch(pname) {
2379                 case GL_CONVOLUTION_BORDER_MODE:
2380                         if ( items != 3 )
2381                                 Perl_croak(aTHX_ "Usage: ConvolutionParameter(target,pname,...)");
2382                         pi = SvIV(ST(2));
2383                         glConvolutionParameteri(target,pname,pi);
2384                         break;
2385                 case GL_CONVOLUTION_FILTER_SCALE:
2386                 case GL_CONVOLUTION_FILTER_BIAS:
2387                         if ( items != 6 )
2388                                 Perl_croak(aTHX_ "Usage: ConvolutionParameter(target,pname,...)");
2389                         pv[0] = (GLfloat)SvNV(ST(2));
2390                         pv[1] = (GLfloat)SvNV(ST(3));
2391                         pv[2] = (GLfloat)SvNV(ST(4));
2392                         pv[3] = (GLfloat)SvNV(ST(5));
2393                         glConvolutionParameterfv(target,pname,pv);
2394                         break;
2395                 default:
2396                         Perl_croak(aTHX_ "ConvolutionParameter invalid parameter");
2397                         break;
2398                 }
2399 #line 2400 "OpenGL.c"
2400     }
2401     XSRETURN_EMPTY;
2402 }
2403
2404 XS(XS_SDL__OpenGL_glHistogram); /* prototype to pass -Wmissing-prototypes */
2405 XS(XS_SDL__OpenGL_glHistogram)
2406 {
2407     dXSARGS;
2408     if (items != 4)
2409         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glHistogram(target, width, internalFormat, sink)");
2410     {
2411         Uint32  target = (Uint32)SvUV(ST(0));
2412         Uint32  width = (Uint32)SvUV(ST(1));
2413         Uint32  internalFormat = (Uint32)SvUV(ST(2));
2414         GLboolean       sink = (unsigned char)SvUV(ST(3));
2415 #line 1540 "OpenGL.xs"
2416                 glHistogram(target,width,internalFormat,sink);
2417 #line 2418 "OpenGL.c"
2418     }
2419     XSRETURN_EMPTY;
2420 }
2421
2422 XS(XS_SDL__OpenGL_glGetHistogram); /* prototype to pass -Wmissing-prototypes */
2423 XS(XS_SDL__OpenGL_glGetHistogram)
2424 {
2425     dXSARGS;
2426     if (items != 5)
2427         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glGetHistogram(target, reset, format, type, values)");
2428     {
2429         Uint32  target = (Uint32)SvUV(ST(0));
2430         GLboolean       reset = (unsigned char)SvUV(ST(1));
2431         Uint32  format = (Uint32)SvUV(ST(2));
2432         Uint32  type = (Uint32)SvUV(ST(3));
2433         char *  values = (char *)SvPV_nolen(ST(4));
2434 #line 1550 "OpenGL.xs"
2435                 glGetHistogram(target,reset,format,type,values);
2436 #line 2437 "OpenGL.c"
2437     }
2438     XSRETURN_EMPTY;
2439 }
2440
2441 XS(XS_SDL__OpenGL_glResetHistogram); /* prototype to pass -Wmissing-prototypes */
2442 XS(XS_SDL__OpenGL_glResetHistogram)
2443 {
2444     dXSARGS;
2445     if (items != 1)
2446         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glResetHistogram(target)");
2447     {
2448         Uint32  target = (Uint32)SvUV(ST(0));
2449 #line 1556 "OpenGL.xs"
2450                 glResetHistogram(target);
2451 #line 2452 "OpenGL.c"
2452     }
2453     XSRETURN_EMPTY;
2454 }
2455
2456 XS(XS_SDL__OpenGL_glMinmax); /* prototype to pass -Wmissing-prototypes */
2457 XS(XS_SDL__OpenGL_glMinmax)
2458 {
2459     dXSARGS;
2460     if (items != 3)
2461         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glMinmax(target, internalFormat, sink)");
2462     {
2463         Uint32  target = (Uint32)SvUV(ST(0));
2464         Uint32  internalFormat = (Uint32)SvUV(ST(1));
2465         GLboolean       sink = (unsigned char)SvUV(ST(2));
2466 #line 1564 "OpenGL.xs"
2467                 glMinmax(target,internalFormat,sink);
2468 #line 2469 "OpenGL.c"
2469     }
2470     XSRETURN_EMPTY;
2471 }
2472
2473 XS(XS_SDL__OpenGL_glGetMinmax); /* prototype to pass -Wmissing-prototypes */
2474 XS(XS_SDL__OpenGL_glGetMinmax)
2475 {
2476     dXSARGS;
2477     if (items != 5)
2478         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glGetMinmax(target, reset, format, type, values)");
2479     {
2480         Uint32  target = (Uint32)SvUV(ST(0));
2481         GLboolean       reset = (unsigned char)SvUV(ST(1));
2482         Uint32  format = (Uint32)SvUV(ST(2));
2483         Uint32  type = (Uint32)SvUV(ST(3));
2484         char *  values = (char *)SvPV_nolen(ST(4));
2485 #line 1574 "OpenGL.xs"
2486                 glGetMinmax(target,reset,format,type,values);
2487 #line 2488 "OpenGL.c"
2488     }
2489     XSRETURN_EMPTY;
2490 }
2491
2492 XS(XS_SDL__OpenGL_glResetMinmax); /* prototype to pass -Wmissing-prototypes */
2493 XS(XS_SDL__OpenGL_glResetMinmax)
2494 {
2495     dXSARGS;
2496     if (items != 1)
2497         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glResetMinmax(target)");
2498     {
2499         Uint32  target = (Uint32)SvUV(ST(0));
2500 #line 1580 "OpenGL.xs"
2501                 glResetMinmax(target);
2502 #line 2503 "OpenGL.c"
2503     }
2504     XSRETURN_EMPTY;
2505 }
2506
2507 XS(XS_SDL__OpenGL_glBlendEquation); /* prototype to pass -Wmissing-prototypes */
2508 XS(XS_SDL__OpenGL_glBlendEquation)
2509 {
2510     dXSARGS;
2511     if (items != 1)
2512         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glBlendEquation(mode)");
2513     {
2514         Uint32  mode = (Uint32)SvUV(ST(0));
2515 #line 1586 "OpenGL.xs"
2516                 glBlendEquation(mode);
2517 #line 2518 "OpenGL.c"
2518     }
2519     XSRETURN_EMPTY;
2520 }
2521
2522 #endif // GL_VERSION_1_3
2523 XS(XS_SDL__OpenGL_glTexImage2D); /* prototype to pass -Wmissing-prototypes */
2524 XS(XS_SDL__OpenGL_glTexImage2D)
2525 {
2526     dXSARGS;
2527     if (items != 9)
2528         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTexImage2D(target, level, internalFormat, width, height, border, format, type, data)");
2529     {
2530         GLenum  target = (GLenum)SvIV(ST(0));
2531         Sint32  level = (Sint32)SvIV(ST(1));
2532         Sint32  internalFormat = (Sint32)SvIV(ST(2));
2533         Uint32  width = (Uint32)SvUV(ST(3));
2534         Uint32  height = (Uint32)SvUV(ST(4));
2535         Sint32  border = (Sint32)SvIV(ST(5));
2536         GLenum  format = (GLenum)SvIV(ST(6));
2537         GLenum  type = (GLenum)SvIV(ST(7));
2538         char *  data = (char *)SvPV_nolen(ST(8));
2539 #line 1602 "OpenGL.xs"
2540                 glTexImage2D(target,level,internalFormat,width,height,border,format,type,data);
2541 #line 2542 "OpenGL.c"
2542     }
2543     XSRETURN_EMPTY;
2544 }
2545
2546 XS(XS_SDL__OpenGL_glCopyTexImage2D); /* prototype to pass -Wmissing-prototypes */
2547 XS(XS_SDL__OpenGL_glCopyTexImage2D)
2548 {
2549     dXSARGS;
2550     if (items != 8)
2551         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border)");
2552     {
2553         GLenum  target = (GLenum)SvIV(ST(0));
2554         Sint32  level = (Sint32)SvIV(ST(1));
2555         Sint32  internalFormat = (Sint32)SvIV(ST(2));
2556         Sint32  x = (Sint32)SvIV(ST(3));
2557         Sint32  y = (Sint32)SvIV(ST(4));
2558         Uint32  width = (Uint32)SvUV(ST(5));
2559         Uint32  height = (Uint32)SvUV(ST(6));
2560         Sint32  border = (Sint32)SvIV(ST(7));
2561 #line 1615 "OpenGL.xs"
2562                 glCopyTexImage2D(target,level,internalFormat,x,y,width,height,border);
2563 #line 2564 "OpenGL.c"
2564     }
2565     XSRETURN_EMPTY;
2566 }
2567
2568 XS(XS_SDL__OpenGL_glTexSubImage2D); /* prototype to pass -Wmissing-prototypes */
2569 XS(XS_SDL__OpenGL_glTexSubImage2D)
2570 {
2571     dXSARGS;
2572     if (items != 9)
2573         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data)");
2574     {
2575         GLenum  target = (GLenum)SvIV(ST(0));
2576         Sint32  level = (Sint32)SvIV(ST(1));
2577         Sint32  xoffset = (Sint32)SvIV(ST(2));
2578         Sint32  yoffset = (Sint32)SvIV(ST(3));
2579         Uint32  width = (Uint32)SvUV(ST(4));
2580         Uint32  height = (Uint32)SvUV(ST(5));
2581         GLenum  format = (GLenum)SvIV(ST(6));
2582         GLenum  type = (GLenum)SvIV(ST(7));
2583         char *  data = (char *)SvPV_nolen(ST(8));
2584 #line 1629 "OpenGL.xs"
2585                 glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,data);
2586 #line 2587 "OpenGL.c"
2587     }
2588     XSRETURN_EMPTY;
2589 }
2590
2591 XS(XS_SDL__OpenGL_glCopyTexSubImage2D); /* prototype to pass -Wmissing-prototypes */
2592 XS(XS_SDL__OpenGL_glCopyTexSubImage2D)
2593 {
2594     dXSARGS;
2595     if (items != 8)
2596         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height)");
2597     {
2598         GLenum  target = (GLenum)SvIV(ST(0));
2599         Sint32  level = (Sint32)SvIV(ST(1));
2600         Sint32  xoffset = (Sint32)SvIV(ST(2));
2601         Sint32  yoffset = (Sint32)SvIV(ST(3));
2602         Sint32  x = (Sint32)SvIV(ST(4));
2603         Sint32  y = (Sint32)SvIV(ST(5));
2604         Uint32  width = (Uint32)SvUV(ST(6));
2605         Uint32  height = (Uint32)SvUV(ST(7));
2606 #line 1642 "OpenGL.xs"
2607                 glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
2608 #line 2609 "OpenGL.c"
2609     }
2610     XSRETURN_EMPTY;
2611 }
2612
2613 XS(XS_SDL__OpenGL_glTexImage1D); /* prototype to pass -Wmissing-prototypes */
2614 XS(XS_SDL__OpenGL_glTexImage1D)
2615 {
2616     dXSARGS;
2617     if (items != 8)
2618         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTexImage1D(target, level, internalFormat, width, border, format, type, data)");
2619     {
2620         GLenum  target = (GLenum)SvIV(ST(0));
2621         Sint32  level = (Sint32)SvIV(ST(1));
2622         Sint32  internalFormat = (Sint32)SvIV(ST(2));
2623         Uint32  width = (Uint32)SvUV(ST(3));
2624         Sint32  border = (Sint32)SvIV(ST(4));
2625         GLenum  format = (GLenum)SvIV(ST(5));
2626         GLenum  type = (GLenum)SvIV(ST(6));
2627         char *  data = (char *)SvPV_nolen(ST(7));
2628 #line 1655 "OpenGL.xs"
2629                 glTexImage1D(target,level,internalFormat,width,border,format,type,data);
2630 #line 2631 "OpenGL.c"
2631     }
2632     XSRETURN_EMPTY;
2633 }
2634
2635 XS(XS_SDL__OpenGL_glTexSubImage1D); /* prototype to pass -Wmissing-prototypes */
2636 XS(XS_SDL__OpenGL_glTexSubImage1D)
2637 {
2638     dXSARGS;
2639     if (items != 7)
2640         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTexSubImage1D(target, level, xoffset, width, format, type, data)");
2641     {
2642         GLenum  target = (GLenum)SvIV(ST(0));
2643         Sint32  level = (Sint32)SvIV(ST(1));
2644         Sint32  xoffset = (Sint32)SvIV(ST(2));
2645         Uint32  width = (Uint32)SvUV(ST(3));
2646         GLenum  format = (GLenum)SvIV(ST(4));
2647         GLenum  type = (GLenum)SvIV(ST(5));
2648         char *  data = (char *)SvPV_nolen(ST(6));
2649 #line 1667 "OpenGL.xs"
2650                 glTexSubImage1D(target,level,xoffset,width,format,type,data);
2651 #line 2652 "OpenGL.c"
2652     }
2653     XSRETURN_EMPTY;
2654 }
2655
2656 XS(XS_SDL__OpenGL_glCopyTexImage1D); /* prototype to pass -Wmissing-prototypes */
2657 XS(XS_SDL__OpenGL_glCopyTexImage1D)
2658 {
2659     dXSARGS;
2660     if (items != 7)
2661         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCopyTexImage1D(target, level, internalFormat, x, y, width, border)");
2662     {
2663         GLenum  target = (GLenum)SvIV(ST(0));
2664         Sint32  level = (Sint32)SvIV(ST(1));
2665         Sint32  internalFormat = (Sint32)SvIV(ST(2));
2666         Sint32  x = (Sint32)SvIV(ST(3));
2667         Sint32  y = (Sint32)SvIV(ST(4));
2668         Uint32  width = (Uint32)SvUV(ST(5));
2669         Sint32  border = (Sint32)SvIV(ST(6));
2670 #line 1679 "OpenGL.xs"
2671                 glCopyTexImage1D(target,level,internalFormat,x,y,width,border);
2672 #line 2673 "OpenGL.c"
2673     }
2674     XSRETURN_EMPTY;
2675 }
2676
2677 XS(XS_SDL__OpenGL_glCopyTexSubImage1D); /* prototype to pass -Wmissing-prototypes */
2678 XS(XS_SDL__OpenGL_glCopyTexSubImage1D)
2679 {
2680     dXSARGS;
2681     if (items != 6)
2682         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCopyTexSubImage1D(target, level, xoffset, x, y, width)");
2683     {
2684         GLenum  target = (GLenum)SvIV(ST(0));
2685         Sint32  level = (Sint32)SvIV(ST(1));
2686         Sint32  xoffset = (Sint32)SvIV(ST(2));
2687         Sint32  x = (Sint32)SvIV(ST(3));
2688         Sint32  y = (Sint32)SvIV(ST(4));
2689         Uint32  width = (Uint32)SvUV(ST(5));
2690 #line 1690 "OpenGL.xs"
2691                 glCopyTexSubImage1D(target,level,xoffset,x,y,width);
2692 #line 2693 "OpenGL.c"
2693     }
2694     XSRETURN_EMPTY;
2695 }
2696
2697 #ifdef GL_VERSION_1_3
2698 #define XSubPPtmpAAAC 1
2699
2700 XS(XS_SDL__OpenGL_glTexImage3D); /* prototype to pass -Wmissing-prototypes */
2701 XS(XS_SDL__OpenGL_glTexImage3D)
2702 {
2703     dXSARGS;
2704     if (items != 10)
2705         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, data)");
2706     {
2707         GLenum  target = (GLenum)SvIV(ST(0));
2708         Sint32  level = (Sint32)SvIV(ST(1));
2709         Sint32  internalFormat = (Sint32)SvIV(ST(2));
2710         Uint32  width = (Uint32)SvUV(ST(3));
2711         Uint32  height = (Uint32)SvUV(ST(4));
2712         Uint32  depth = (Uint32)SvUV(ST(5));
2713         Sint32  border = (Sint32)SvIV(ST(6));
2714         GLenum  format = (GLenum)SvIV(ST(7));
2715         GLenum  type = (GLenum)SvIV(ST(8));
2716         char *  data = (char *)SvPV_nolen(ST(9));
2717 #line 1707 "OpenGL.xs"
2718                 glTexImage3D(target,level,internalFormat,width,height,depth,border,format,type,data);
2719 #line 2720 "OpenGL.c"
2720     }
2721     XSRETURN_EMPTY;
2722 }
2723
2724 XS(XS_SDL__OpenGL_glTexSubImage3D); /* prototype to pass -Wmissing-prototypes */
2725 XS(XS_SDL__OpenGL_glTexSubImage3D)
2726 {
2727     dXSARGS;
2728     if (items != 11)
2729         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data)");
2730     {
2731         GLenum  target = (GLenum)SvIV(ST(0));
2732         Sint32  level = (Sint32)SvIV(ST(1));
2733         Sint32  xoffset = (Sint32)SvIV(ST(2));
2734         Sint32  yoffset = (Sint32)SvIV(ST(3));
2735         Sint32  zoffset = (Sint32)SvIV(ST(4));
2736         Uint32  width = (Uint32)SvUV(ST(5));
2737         Uint32  height = (Uint32)SvUV(ST(6));
2738         Uint32  depth = (Uint32)SvUV(ST(7));
2739         GLenum  format = (GLenum)SvIV(ST(8));
2740         GLenum  type = (GLenum)SvIV(ST(9));
2741         char *  data = (char *)SvPV_nolen(ST(10));
2742 #line 1723 "OpenGL.xs"
2743                 glTexSubImage3D(target,level,xoffset,yoffset,zoffset,
2744                         width,height,depth,format,type,data);
2745 #line 2746 "OpenGL.c"
2746     }
2747     XSRETURN_EMPTY;
2748 }
2749
2750 XS(XS_SDL__OpenGL_glCopyTexSubImage3D); /* prototype to pass -Wmissing-prototypes */
2751 XS(XS_SDL__OpenGL_glCopyTexSubImage3D)
2752 {
2753     dXSARGS;
2754     if (items != 9)
2755         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height)");
2756     {
2757         GLenum  target = (GLenum)SvIV(ST(0));
2758         Sint32  level = (Sint32)SvIV(ST(1));
2759         Sint32  xoffset = (Sint32)SvIV(ST(2));
2760         Sint32  yoffset = (Sint32)SvIV(ST(3));
2761         Sint32  zoffset = (Sint32)SvIV(ST(4));
2762         Sint32  x = (Sint32)SvIV(ST(5));
2763         Sint32  y = (Sint32)SvIV(ST(6));
2764         Uint32  width = (Uint32)SvUV(ST(7));
2765         Uint32  height = (Uint32)SvUV(ST(8));
2766 #line 1738 "OpenGL.xs"
2767                 glCopyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height);
2768 #line 2769 "OpenGL.c"
2769     }
2770     XSRETURN_EMPTY;
2771 }
2772
2773 #endif // GL_VERSION_1_3
2774 XS(XS_SDL__OpenGL_glGenTextures); /* prototype to pass -Wmissing-prototypes */
2775 XS(XS_SDL__OpenGL_glGenTextures)
2776 {
2777     dXSARGS;
2778     if (items != 1)
2779         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glGenTextures(n)");
2780     {
2781         Uint32  n = (Uint32)SvUV(ST(0));
2782         AV *    RETVAL;
2783 #line 1746 "OpenGL.xs"
2784                 GLsizei i;
2785                 GLuint* names;
2786                 names = (GLuint*)safemalloc(sizeof(GLuint)*n);
2787                 RETVAL = newAV();
2788                 glGenTextures(n,names);
2789                 for ( i = 0; i < n; i++ ) {
2790                         av_push(RETVAL,newSViv(names[i]));
2791                 }
2792                 safefree(names);
2793 #line 2794 "OpenGL.c"
2794         ST(0) = newRV((SV*)RETVAL);
2795         sv_2mortal(ST(0));
2796     }
2797     XSRETURN(1);
2798 }
2799
2800 XS(XS_SDL__OpenGL_glIsTexture); /* prototype to pass -Wmissing-prototypes */
2801 XS(XS_SDL__OpenGL_glIsTexture)
2802 {
2803     dXSARGS;
2804     if (items != 1)
2805         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glIsTexture(texture)");
2806     {
2807         Uint32  texture = (Uint32)SvUV(ST(0));
2808         GLboolean       RETVAL;
2809         dXSTARG;
2810 #line 1762 "OpenGL.xs"
2811                 RETVAL = glIsTexture(texture);
2812 #line 2813 "OpenGL.c"
2813         XSprePUSH; PUSHu((UV)RETVAL);
2814     }
2815     XSRETURN(1);
2816 }
2817
2818 XS(XS_SDL__OpenGL_glBindTexture); /* prototype to pass -Wmissing-prototypes */
2819 XS(XS_SDL__OpenGL_glBindTexture)
2820 {
2821     dXSARGS;
2822     if (items != 2)
2823         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glBindTexture(target, texture)");
2824     {
2825         GLenum  target = (GLenum)SvIV(ST(0));
2826         Uint32  texture = (Uint32)SvUV(ST(1));
2827 #line 1771 "OpenGL.xs"
2828                 glBindTexture(target,texture);
2829 #line 2830 "OpenGL.c"
2830     }
2831     XSRETURN_EMPTY;
2832 }
2833
2834 XS(XS_SDL__OpenGL_glDeleteTextures); /* prototype to pass -Wmissing-prototypes */
2835 XS(XS_SDL__OpenGL_glDeleteTextures)
2836 {
2837     dXSARGS;
2838     {
2839 #line 1776 "OpenGL.xs"
2840                 GLuint* textures;
2841                 int i;
2842                 textures = (GLuint*)safemalloc(sizeof(GLuint) * items);
2843                 if ( textures ) {
2844                         for ( i = 0; i < items; i++ ) {
2845                                 textures[i] = SvIV(ST(i));
2846                         }
2847                 }
2848                 glDeleteTextures(items,textures);
2849                 safefree(textures);
2850 #line 2851 "OpenGL.c"
2851     }
2852     XSRETURN_EMPTY;
2853 }
2854
2855 XS(XS_SDL__OpenGL_glAreTexturesResident); /* prototype to pass -Wmissing-prototypes */
2856 XS(XS_SDL__OpenGL_glAreTexturesResident)
2857 {
2858     dXSARGS;
2859     {
2860         AV *    RETVAL;
2861 #line 1790 "OpenGL.xs"
2862                 GLuint* textures;
2863                 GLboolean *homes;
2864                 int i;
2865                 RETVAL = newAV();
2866                 textures = (GLuint*)safemalloc(sizeof(GLuint) * items);
2867                 homes = (GLboolean*)safemalloc(sizeof(GLboolean) * items);
2868                 if ( textures ) {
2869                         for ( i = 0; i < items; i++ ) {
2870                                 textures[i] = SvIV(ST(i));
2871                         }
2872                 }
2873                 if ( GL_FALSE != glAreTexturesResident(items,textures,homes)) {
2874                         for (i = 0; i < items; i++ ) {
2875                                 av_push(RETVAL,newSViv(homes[i]));
2876                         }
2877                 }
2878                 safefree(homes);
2879                 safefree(textures);
2880 #line 2881 "OpenGL.c"
2881         ST(0) = newRV((SV*)RETVAL);
2882         sv_2mortal(ST(0));
2883     }
2884     XSRETURN(1);
2885 }
2886
2887 XS(XS_SDL__OpenGL_glPrioritizeTextures); /* prototype to pass -Wmissing-prototypes */
2888 XS(XS_SDL__OpenGL_glPrioritizeTextures)
2889 {
2890     dXSARGS;
2891     if (items != 3)
2892         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPrioritizeTextures(n, names, priorities)");
2893     {
2894         Uint32  n = (Uint32)SvUV(ST(0));
2895         char *  names = (char *)SvPV_nolen(ST(1));
2896         char *  priorities = (char *)SvPV_nolen(ST(2));
2897 #line 1817 "OpenGL.xs"
2898                 glPrioritizeTextures(n,(GLuint*)names,(const GLclampf *)priorities);
2899 #line 2900 "OpenGL.c"
2900     }
2901     XSRETURN_EMPTY;
2902 }
2903
2904 XS(XS_SDL__OpenGL_glTexEnv); /* prototype to pass -Wmissing-prototypes */
2905 XS(XS_SDL__OpenGL_glTexEnv)
2906 {
2907     dXSARGS;
2908     if (items < 2)
2909         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTexEnv(target, name, ...)");
2910     {
2911         GLenum  target = (GLenum)SvIV(ST(0));
2912         GLenum  name = (GLenum)SvIV(ST(1));
2913 #line 1824 "OpenGL.xs"
2914                 float pv[4];
2915                 GLint p;
2916                 switch(name) {
2917                         case GL_TEXTURE_ENV_MODE:
2918                                 p = SvIV(ST(2));
2919                                 glTexEnvi(target,name,p);
2920                                 break;
2921                         case GL_TEXTURE_ENV_COLOR:
2922                                 pv[0] = SvNV(ST(2));
2923                                 pv[1] = SvNV(ST(3));
2924                                 pv[2] = SvNV(ST(4));
2925                                 pv[3] = SvNV(ST(5));
2926                                 glTexEnvfv(target,name,pv);
2927                                 break;
2928                 }
2929 #line 2930 "OpenGL.c"
2930     }
2931     XSRETURN_EMPTY;
2932 }
2933
2934 XS(XS_SDL__OpenGL_glTexCoord); /* prototype to pass -Wmissing-prototypes */
2935 XS(XS_SDL__OpenGL_glTexCoord)
2936 {
2937     dXSARGS;
2938     {
2939 #line 1843 "OpenGL.xs"
2940                 double s,t,r,q;
2941                 if ( items < 1 || items > 4 )
2942                         Perl_croak (aTHX_ "usage: SDL::OpenGL::TexCoord(s,[t,[r,[q]]])");
2943                 s = t = r = 0.0;
2944                 q = 1.0;
2945                 switch(items) {
2946                         case 4:
2947                                 q = SvNV(ST(3));
2948                         case 3:
2949                                 r = SvNV(ST(2));
2950                         case 2:
2951                                 t = SvNV(ST(1));
2952                         case 1:
2953                                 s = SvNV(ST(0));
2954                 }
2955                 glTexCoord4d(s,t,r,q);
2956 #line 2957 "OpenGL.c"
2957     }
2958     XSRETURN_EMPTY;
2959 }
2960
2961 XS(XS_SDL__OpenGL_glTexParameter); /* prototype to pass -Wmissing-prototypes */
2962 XS(XS_SDL__OpenGL_glTexParameter)
2963 {
2964     dXSARGS;
2965     if (items < 2)
2966         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTexParameter(target, name, ...)");
2967     {
2968         GLenum  target = (GLenum)SvIV(ST(0));
2969         GLenum  name = (GLenum)SvIV(ST(1));
2970 #line 1865 "OpenGL.xs"
2971                 GLfloat pv[4];
2972                 GLint p;
2973                 switch (name) {
2974                         case GL_TEXTURE_BORDER_COLOR:
2975                                 pv[0] = SvNV(ST(2));
2976                                 pv[1] = SvNV(ST(3));
2977                                 pv[2] = SvNV(ST(4));
2978                                 pv[3] = SvNV(ST(5));
2979                                 glTexParameterfv(target,name,pv);
2980                                 break;
2981                         case GL_TEXTURE_PRIORITY:
2982                         case GL_TEXTURE_MIN_LOD:
2983                         case GL_TEXTURE_MAX_LOD:
2984                                 pv[0] = SvNV(ST(2));
2985                                 glTexParameterf(target,name,pv[0]);
2986                                 break;
2987                         case GL_TEXTURE_BASE_LEVEL:
2988                         case GL_TEXTURE_MAX_LEVEL:
2989                         default:
2990                                 p = SvIV(ST(2));
2991                                 glTexParameteri(target,name,p);
2992                                 break;
2993                 }
2994 #line 2995 "OpenGL.c"
2995     }
2996     XSRETURN_EMPTY;
2997 }
2998
2999 XS(XS_SDL__OpenGL_glTexGen); /* prototype to pass -Wmissing-prototypes */
3000 XS(XS_SDL__OpenGL_glTexGen)
3001 {
3002     dXSARGS;
3003     if (items < 2)
3004         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glTexGen(coord, name, ...)");
3005     {
3006         GLenum  coord = (GLenum)SvIV(ST(0));
3007         GLenum  name = (GLenum)SvIV(ST(1));
3008 #line 1894 "OpenGL.xs"
3009                 GLdouble *pv;
3010                 GLint p;
3011                 int i;
3012                 switch (name) {
3013                         case GL_TEXTURE_GEN_MODE:
3014                                 p = SvIV(ST(2));
3015                                 glTexGeni(coord,name,p);
3016                                 break;
3017                         default:
3018                                 if ( items == 2 )
3019                                         Perl_croak(aTHX_  "usage: glTexGen(coord,name,...)");
3020                                 pv = (GLdouble*)safemalloc(sizeof(GLdouble)*(items-2));
3021                                 for ( i = 0; i < items - 2; i++ ) {
3022                                         pv[i] = SvNV(ST(i+2));
3023                                 }
3024                                 glTexGendv(coord,name,pv);
3025                                 safefree(pv);
3026                                 break;
3027                 }
3028 #line 3029 "OpenGL.c"
3029     }
3030     XSRETURN_EMPTY;
3031 }
3032
3033 #ifdef GL_VERSION_1_3
3034 #define XSubPPtmpAAAD 1
3035
3036 XS(XS_SDL__OpenGL_glActiveTextureARB); /* prototype to pass -Wmissing-prototypes */
3037 XS(XS_SDL__OpenGL_glActiveTextureARB)
3038 {
3039     dXSARGS;
3040     if (items != 1)
3041         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glActiveTextureARB(texUnit)");
3042     {
3043         GLenum  texUnit = (GLenum)SvIV(ST(0));
3044 #line 1920 "OpenGL.xs"
3045                 glActiveTextureARB(texUnit);
3046 #line 3047 "OpenGL.c"
3047     }
3048     XSRETURN_EMPTY;
3049 }
3050
3051 XS(XS_SDL__OpenGL_glMultiTexCoord); /* prototype to pass -Wmissing-prototypes */
3052 XS(XS_SDL__OpenGL_glMultiTexCoord)
3053 {
3054     dXSARGS;
3055     if (items < 1)
3056         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glMultiTexCoord(texUnit, ...)");
3057     {
3058         Uint32  texUnit = (Uint32)SvUV(ST(0));
3059 #line 1926 "OpenGL.xs"
3060                 double s,t,r,q;
3061                 if ( items < 2 || items > 5 )
3062                         Perl_croak (aTHX_ "usage: SDL::OpenGL::MultiTexCoord(tex,s,[t,[r,[q]]])");
3063                 s = t = r = 0.0;
3064                 q = 1.0;
3065                 switch(items) {
3066                         case 5:
3067                                 q = SvNV(ST(3));
3068                         case 4:
3069                                 r = SvNV(ST(2));
3070                         case 3:
3071                                 t = SvNV(ST(1));
3072                         case 2:
3073                                 s = SvNV(ST(0));
3074                 }
3075                 glMultiTexCoord4dARB(texUnit,s,t,r,q);
3076 #line 3077 "OpenGL.c"
3077     }
3078     XSRETURN_EMPTY;
3079 }
3080
3081 #endif // GL_VERSION_1_3
3082 XS(XS_SDL__OpenGL_glDrawBuffer); /* prototype to pass -Wmissing-prototypes */
3083 XS(XS_SDL__OpenGL_glDrawBuffer)
3084 {
3085     dXSARGS;
3086     if (items != 1)
3087         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDrawBuffer(mode)");
3088     {
3089         GLenum  mode = (GLenum)SvIV(ST(0));
3090 #line 1949 "OpenGL.xs"
3091                 glDrawBuffer(mode);
3092 #line 3093 "OpenGL.c"
3093     }
3094     XSRETURN_EMPTY;
3095 }
3096
3097 XS(XS_SDL__OpenGL_glReadBuffer); /* prototype to pass -Wmissing-prototypes */
3098 XS(XS_SDL__OpenGL_glReadBuffer)
3099 {
3100     dXSARGS;
3101     if (items != 1)
3102         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glReadBuffer(mode)");
3103     {
3104         GLenum  mode = (GLenum)SvIV(ST(0));
3105 #line 1955 "OpenGL.xs"
3106                 glReadBuffer(mode);
3107 #line 3108 "OpenGL.c"
3108     }
3109     XSRETURN_EMPTY;
3110 }
3111
3112 XS(XS_SDL__OpenGL_glIndexMask); /* prototype to pass -Wmissing-prototypes */
3113 XS(XS_SDL__OpenGL_glIndexMask)
3114 {
3115     dXSARGS;
3116     if (items != 1)
3117         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glIndexMask(mask)");
3118     {
3119         Uint32  mask = (Uint32)SvUV(ST(0));
3120 #line 1961 "OpenGL.xs"
3121                 glIndexMask(mask);
3122 #line 3123 "OpenGL.c"
3123     }
3124     XSRETURN_EMPTY;
3125 }
3126
3127 XS(XS_SDL__OpenGL_glColorMask); /* prototype to pass -Wmissing-prototypes */
3128 XS(XS_SDL__OpenGL_glColorMask)
3129 {
3130     dXSARGS;
3131     if (items != 4)
3132         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glColorMask(red, green, blue, alpha)");
3133     {
3134         GLboolean       red = (unsigned char)SvUV(ST(0));
3135         GLboolean       green = (unsigned char)SvUV(ST(1));
3136         GLboolean       blue = (unsigned char)SvUV(ST(2));
3137         GLboolean       alpha = (unsigned char)SvUV(ST(3));
3138 #line 1970 "OpenGL.xs"
3139                 glColorMask(red,green,blue,alpha);
3140 #line 3141 "OpenGL.c"
3141     }
3142     XSRETURN_EMPTY;
3143 }
3144
3145 XS(XS_SDL__OpenGL_glDepthMask); /* prototype to pass -Wmissing-prototypes */
3146 XS(XS_SDL__OpenGL_glDepthMask)
3147 {
3148     dXSARGS;
3149     if (items != 1)
3150         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDepthMask(flag)");
3151     {
3152         GLboolean       flag = (unsigned char)SvUV(ST(0));
3153 #line 1976 "OpenGL.xs"
3154                 glDepthMask(flag);
3155 #line 3156 "OpenGL.c"
3156     }
3157     XSRETURN_EMPTY;
3158 }
3159
3160 XS(XS_SDL__OpenGL_glStencilMask); /* prototype to pass -Wmissing-prototypes */
3161 XS(XS_SDL__OpenGL_glStencilMask)
3162 {
3163     dXSARGS;
3164     if (items != 1)
3165         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glStencilMask(mask)");
3166     {
3167         Uint32  mask = (Uint32)SvUV(ST(0));
3168 #line 1982 "OpenGL.xs"
3169                 glStencilMask(mask);
3170 #line 3171 "OpenGL.c"
3171     }
3172     XSRETURN_EMPTY;
3173 }
3174
3175 XS(XS_SDL__OpenGL_glScissor); /* prototype to pass -Wmissing-prototypes */
3176 XS(XS_SDL__OpenGL_glScissor)
3177 {
3178     dXSARGS;
3179     if (items != 4)
3180         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glScissor(x, y, width, height)");
3181     {
3182         Sint32  x = (Sint32)SvIV(ST(0));
3183         Sint32  y = (Sint32)SvIV(ST(1));
3184         Uint32  width = (Uint32)SvUV(ST(2));
3185         Uint32  height = (Uint32)SvUV(ST(3));
3186 #line 1991 "OpenGL.xs"
3187                 glScissor(x,y,width,height);
3188 #line 3189 "OpenGL.c"
3189     }
3190     XSRETURN_EMPTY;
3191 }
3192
3193 XS(XS_SDL__OpenGL_glAlphaFunc); /* prototype to pass -Wmissing-prototypes */
3194 XS(XS_SDL__OpenGL_glAlphaFunc)
3195 {
3196     dXSARGS;
3197     if (items != 2)
3198         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glAlphaFunc(func, ref)");
3199     {
3200         GLenum  func = (GLenum)SvIV(ST(0));
3201         double  ref = (double)SvNV(ST(1));
3202 #line 1998 "OpenGL.xs"
3203                 glAlphaFunc(func,ref);
3204 #line 3205 "OpenGL.c"
3205     }
3206     XSRETURN_EMPTY;
3207 }
3208
3209 XS(XS_SDL__OpenGL_glStencilFunc); /* prototype to pass -Wmissing-prototypes */
3210 XS(XS_SDL__OpenGL_glStencilFunc)
3211 {
3212     dXSARGS;
3213     if (items != 3)
3214         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glStencilFunc(func, ref, mask)");
3215     {
3216         GLenum  func = (GLenum)SvIV(ST(0));
3217         Sint32  ref = (Sint32)SvIV(ST(1));
3218         Uint32  mask = (Uint32)SvUV(ST(2));
3219 #line 2006 "OpenGL.xs"
3220                 glStencilFunc(func,ref,mask);
3221 #line 3222 "OpenGL.c"
3222     }
3223     XSRETURN_EMPTY;
3224 }
3225
3226 XS(XS_SDL__OpenGL_glStencilOp); /* prototype to pass -Wmissing-prototypes */
3227 XS(XS_SDL__OpenGL_glStencilOp)
3228 {
3229     dXSARGS;
3230     if (items != 3)
3231         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glStencilOp(fail, zfail, zpass)");
3232     {
3233         GLenum  fail = (GLenum)SvIV(ST(0));
3234         GLenum  zfail = (GLenum)SvIV(ST(1));
3235         GLenum  zpass = (GLenum)SvIV(ST(2));
3236 #line 2014 "OpenGL.xs"
3237                 glStencilOp(fail,zfail,zpass);
3238 #line 3239 "OpenGL.c"
3239     }
3240     XSRETURN_EMPTY;
3241 }
3242
3243 XS(XS_SDL__OpenGL_glDepthFunc); /* prototype to pass -Wmissing-prototypes */
3244 XS(XS_SDL__OpenGL_glDepthFunc)
3245 {
3246     dXSARGS;
3247     if (items != 1)
3248         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glDepthFunc(func)");
3249     {
3250         GLenum  func = (GLenum)SvIV(ST(0));
3251 #line 2020 "OpenGL.xs"
3252                 glDepthFunc(func);
3253 #line 3254 "OpenGL.c"
3254     }
3255     XSRETURN_EMPTY;
3256 }
3257
3258 XS(XS_SDL__OpenGL_glLogicOp); /* prototype to pass -Wmissing-prototypes */
3259 XS(XS_SDL__OpenGL_glLogicOp)
3260 {
3261     dXSARGS;
3262     if (items != 1)
3263         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glLogicOp(opcode)");
3264     {
3265         GLenum  opcode = (GLenum)SvIV(ST(0));
3266 #line 2026 "OpenGL.xs"
3267                 glLogicOp(opcode);
3268 #line 3269 "OpenGL.c"
3269     }
3270     XSRETURN_EMPTY;
3271 }
3272
3273 XS(XS_SDL__OpenGL_glAccum); /* prototype to pass -Wmissing-prototypes */
3274 XS(XS_SDL__OpenGL_glAccum)
3275 {
3276     dXSARGS;
3277     if (items != 2)
3278         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glAccum(op, value)");
3279     {
3280         GLenum  op = (GLenum)SvIV(ST(0));
3281         double  value = (double)SvNV(ST(1));
3282 #line 2033 "OpenGL.xs"
3283                 glAccum(op,value);
3284 #line 3285 "OpenGL.c"
3285     }
3286     XSRETURN_EMPTY;
3287 }
3288
3289 XS(XS_SDL__OpenGL_glMap1); /* prototype to pass -Wmissing-prototypes */
3290 XS(XS_SDL__OpenGL_glMap1)
3291 {
3292     dXSARGS;
3293     if (items != 6)
3294         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glMap1(target, u1, u2, stride, order, points)");
3295     {
3296         GLenum  target = (GLenum)SvIV(ST(0));
3297         double  u1 = (double)SvNV(ST(1));
3298         double  u2 = (double)SvNV(ST(2));
3299         Sint32  stride = (Sint32)SvIV(ST(3));
3300         Sint32  order = (Sint32)SvIV(ST(4));
3301         char *  points = (char *)SvPV_nolen(ST(5));
3302 #line 2044 "OpenGL.xs"
3303                 glMap1d(target,u1,u2,stride,order,(double*)points);
3304 #line 3305 "OpenGL.c"
3305     }
3306     XSRETURN_EMPTY;
3307 }
3308
3309 XS(XS_SDL__OpenGL_glEvalCoord1); /* prototype to pass -Wmissing-prototypes */
3310 XS(XS_SDL__OpenGL_glEvalCoord1)
3311 {
3312     dXSARGS;
3313     if (items != 1)
3314         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glEvalCoord1(u)");
3315     {
3316         double  u = (double)SvNV(ST(0));
3317 #line 2050 "OpenGL.xs"
3318                 glEvalCoord1d(u);
3319 #line 3320 "OpenGL.c"
3320     }
3321     XSRETURN_EMPTY;
3322 }
3323
3324 XS(XS_SDL__OpenGL_glMapGrid1); /* prototype to pass -Wmissing-prototypes */
3325 XS(XS_SDL__OpenGL_glMapGrid1)
3326 {
3327     dXSARGS;
3328     if (items != 3)
3329         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glMapGrid1(n, u1, u2)");
3330     {
3331         Sint32  n = (Sint32)SvIV(ST(0));
3332         double  u1 = (double)SvNV(ST(1));
3333         double  u2 = (double)SvNV(ST(2));
3334 #line 2058 "OpenGL.xs"
3335                 glMapGrid1d(n,u1,u2);
3336 #line 3337 "OpenGL.c"
3337     }
3338     XSRETURN_EMPTY;
3339 }
3340
3341 XS(XS_SDL__OpenGL_glEvalMesh1); /* prototype to pass -Wmissing-prototypes */
3342 XS(XS_SDL__OpenGL_glEvalMesh1)
3343 {
3344     dXSARGS;
3345     if (items != 3)
3346         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glEvalMesh1(mode, p1, p2)");
3347     {
3348         GLenum  mode = (GLenum)SvIV(ST(0));
3349         Sint32  p1 = (Sint32)SvIV(ST(1));
3350         Sint32  p2 = (Sint32)SvIV(ST(2));
3351 #line 2066 "OpenGL.xs"
3352                 glEvalMesh1(mode,p1,p2);
3353 #line 3354 "OpenGL.c"
3354     }
3355     XSRETURN_EMPTY;
3356 }
3357
3358 XS(XS_SDL__OpenGL_glMap2); /* prototype to pass -Wmissing-prototypes */
3359 XS(XS_SDL__OpenGL_glMap2)
3360 {
3361     dXSARGS;
3362     if (items != 10)
3363         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glMap2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points)");
3364     {
3365         GLenum  target = (GLenum)SvIV(ST(0));
3366         double  u1 = (double)SvNV(ST(1));
3367         double  u2 = (double)SvNV(ST(2));
3368         Sint32  ustride = (Sint32)SvIV(ST(3));
3369         Sint32  uorder = (Sint32)SvIV(ST(4));
3370         double  v1 = (double)SvNV(ST(5));
3371         double  v2 = (double)SvNV(ST(6));
3372         Sint32  vstride = (Sint32)SvIV(ST(7));
3373         Sint32  vorder = (Sint32)SvIV(ST(8));
3374         char *  points = (char *)SvPV_nolen(ST(9));
3375 #line 2081 "OpenGL.xs"
3376                 glMap2d(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,(double*)points);
3377 #line 3378 "OpenGL.c"
3378     }
3379     XSRETURN_EMPTY;
3380 }
3381
3382 XS(XS_SDL__OpenGL_glEvalCoord2); /* prototype to pass -Wmissing-prototypes */
3383 XS(XS_SDL__OpenGL_glEvalCoord2)
3384 {
3385     dXSARGS;
3386     if (items != 2)
3387         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glEvalCoord2(u, v)");
3388     {
3389         double  u = (double)SvNV(ST(0));
3390         double  v = (double)SvNV(ST(1));
3391 #line 2088 "OpenGL.xs"
3392                 glEvalCoord2d(u,v);
3393 #line 3394 "OpenGL.c"
3394     }
3395     XSRETURN_EMPTY;
3396 }
3397
3398 XS(XS_SDL__OpenGL_glMapGrid2); /* prototype to pass -Wmissing-prototypes */
3399 XS(XS_SDL__OpenGL_glMapGrid2)
3400 {
3401     dXSARGS;
3402     if (items != 6)
3403         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glMapGrid2(nu, u1, u2, nv, v1, v2)");
3404     {
3405         Sint32  nu = (Sint32)SvIV(ST(0));
3406         double  u1 = (double)SvNV(ST(1));
3407         double  u2 = (double)SvNV(ST(2));
3408         Sint32  nv = (Sint32)SvIV(ST(3));
3409         double  v1 = (double)SvNV(ST(4));
3410         double  v2 = (double)SvNV(ST(5));
3411 #line 2099 "OpenGL.xs"
3412                 glMapGrid2d(nu,u1,u2,nv,v1,v2);
3413 #line 3414 "OpenGL.c"
3414     }
3415     XSRETURN_EMPTY;
3416 }
3417
3418 XS(XS_SDL__OpenGL_glEvalMesh2); /* prototype to pass -Wmissing-prototypes */
3419 XS(XS_SDL__OpenGL_glEvalMesh2)
3420 {
3421     dXSARGS;
3422     if (items != 5)
3423         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glEvalMesh2(mode, i1, i2, j1, j2)");
3424     {
3425         GLenum  mode = (GLenum)SvIV(ST(0));
3426         Sint32  i1 = (Sint32)SvIV(ST(1));
3427         Sint32  i2 = (Sint32)SvIV(ST(2));
3428         Sint32  j1 = (Sint32)SvIV(ST(3));
3429         Sint32  j2 = (Sint32)SvIV(ST(4));
3430 #line 2109 "OpenGL.xs"
3431                 glEvalMesh2(mode,i1,i2,j1,j2);
3432 #line 3433 "OpenGL.c"
3433     }
3434     XSRETURN_EMPTY;
3435 }
3436
3437 XS(XS_SDL__OpenGL_glGetError); /* prototype to pass -Wmissing-prototypes */
3438 XS(XS_SDL__OpenGL_glGetError)
3439 {
3440     dXSARGS;
3441     if (items != 0)
3442         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glGetError()");
3443     {
3444         GLenum  RETVAL;
3445         dXSTARG;
3446 #line 2114 "OpenGL.xs"
3447                 RETVAL = glGetError();
3448 #line 3449 "OpenGL.c"
3449         XSprePUSH; PUSHi((IV)RETVAL);
3450     }
3451     XSRETURN(1);
3452 }
3453
3454 XS(XS_SDL__OpenGL_glRenderMode); /* prototype to pass -Wmissing-prototypes */
3455 XS(XS_SDL__OpenGL_glRenderMode)
3456 {
3457     dXSARGS;
3458     if (items != 1)
3459         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glRenderMode(mode)");
3460     {
3461         GLenum  mode = (GLenum)SvIV(ST(0));
3462         GLint   RETVAL;
3463         dXSTARG;
3464 #line 2122 "OpenGL.xs"
3465                 RETVAL = glRenderMode( mode );
3466 #line 3467 "OpenGL.c"
3467         XSprePUSH; PUSHi((IV)RETVAL);
3468     }
3469     XSRETURN(1);
3470 }
3471
3472 XS(XS_SDL__OpenGL_glInitNames); /* prototype to pass -Wmissing-prototypes */
3473 XS(XS_SDL__OpenGL_glInitNames)
3474 {
3475     dXSARGS;
3476     if (items != 0)
3477         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glInitNames()");
3478     {
3479 #line 2129 "OpenGL.xs"
3480                 glInitNames();
3481 #line 3482 "OpenGL.c"
3482     }
3483     XSRETURN_EMPTY;
3484 }
3485
3486 XS(XS_SDL__OpenGL_glPushName); /* prototype to pass -Wmissing-prototypes */
3487 XS(XS_SDL__OpenGL_glPushName)
3488 {
3489     dXSARGS;
3490     if (items != 1)
3491         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPushName(name)");
3492     {
3493         GLuint  name = (GLuint)SvUV(ST(0));
3494 #line 2135 "OpenGL.xs"
3495                 glPushName(name);
3496 #line 3497 "OpenGL.c"
3497     }
3498     XSRETURN_EMPTY;
3499 }
3500
3501 XS(XS_SDL__OpenGL_glPopName); /* prototype to pass -Wmissing-prototypes */
3502 XS(XS_SDL__OpenGL_glPopName)
3503 {
3504     dXSARGS;
3505     if (items != 0)
3506         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPopName()");
3507     {
3508 #line 2140 "OpenGL.xs"
3509                 glPopName();
3510 #line 3511 "OpenGL.c"
3511     }
3512     XSRETURN_EMPTY;
3513 }
3514
3515 XS(XS_SDL__OpenGL_glLoadName); /* prototype to pass -Wmissing-prototypes */
3516 XS(XS_SDL__OpenGL_glLoadName)
3517 {
3518     dXSARGS;
3519     if (items != 1)
3520         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glLoadName(name)");
3521     {
3522         GLuint  name = (GLuint)SvUV(ST(0));
3523 #line 2146 "OpenGL.xs"
3524                 glLoadName(name);
3525 #line 3526 "OpenGL.c"
3526     }
3527     XSRETURN_EMPTY;
3528 }
3529
3530 XS(XS_SDL__OpenGL_glFeedbackBuffer); /* prototype to pass -Wmissing-prototypes */
3531 XS(XS_SDL__OpenGL_glFeedbackBuffer)
3532 {
3533     dXSARGS;
3534     if (items != 3)
3535         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glFeedbackBuffer(size, type, buffer)");
3536     {
3537         GLuint  size = (GLuint)SvUV(ST(0));
3538         GLenum  type = (GLenum)SvIV(ST(1));
3539         float*  buffer = INT2PTR(float *,SvIV(ST(2)));
3540 #line 2154 "OpenGL.xs"
3541                 glFeedbackBuffer(size,type,buffer);
3542 #line 3543 "OpenGL.c"
3543     }
3544     XSRETURN_EMPTY;
3545 }
3546
3547 XS(XS_SDL__OpenGL_glPassThrough); /* prototype to pass -Wmissing-prototypes */
3548 XS(XS_SDL__OpenGL_glPassThrough)
3549 {
3550     dXSARGS;
3551     if (items != 1)
3552         Perl_croak(aTHX_ "Usage: SDL::OpenGL::glPassThrough(token)");
3553     {
3554         GLfloat token = (GLfloat)SvNV(ST(0));
3555 #line 2160 "OpenGL.xs"
3556                 glPassThrough(token);
3557 #line 3558 "OpenGL.c"
3558     }
3559     XSRETURN_EMPTY;
3560 }
3561
3562 #endif
3563 #ifdef HAVE_GLU
3564 #define XSubPPtmpAAAE 1
3565
3566 XS(XS_SDL__OpenGL_gluLookAt); /* prototype to pass -Wmissing-prototypes */
3567 XS(XS_SDL__OpenGL_gluLookAt)
3568 {
3569     dXSARGS;
3570     if (items != 9)
3571         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluLookAt(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz)");
3572     {
3573         double  eyex = (double)SvNV(ST(0));
3574         double  eyey = (double)SvNV(ST(1));
3575         double  eyez = (double)SvNV(ST(2));
3576         double  centerx = (double)SvNV(ST(3));
3577         double  centery = (double)SvNV(ST(4));
3578         double  centerz = (double)SvNV(ST(5));
3579         double  upx = (double)SvNV(ST(6));
3580         double  upy = (double)SvNV(ST(7));
3581         double  upz = (double)SvNV(ST(8));
3582 #line 2179 "OpenGL.xs"
3583                 gluLookAt(eyex,eyey,eyez,centerx,centery,centerz,upx,upy,upz);
3584 #line 3585 "OpenGL.c"
3585     }
3586     XSRETURN_EMPTY;
3587 }
3588
3589 XS(XS_SDL__OpenGL_gluPerspective); /* prototype to pass -Wmissing-prototypes */
3590 XS(XS_SDL__OpenGL_gluPerspective)
3591 {
3592     dXSARGS;
3593     if (items != 4)
3594         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluPerspective(fovy, aspect, n, f)");
3595     {
3596         double  fovy = (double)SvNV(ST(0));
3597         double  aspect = (double)SvNV(ST(1));
3598         double  n = (double)SvNV(ST(2));
3599         double  f = (double)SvNV(ST(3));
3600 #line 2188 "OpenGL.xs"
3601                 gluPerspective(fovy,aspect,n,f);
3602 #line 3603 "OpenGL.c"
3603     }
3604     XSRETURN_EMPTY;
3605 }
3606
3607 XS(XS_SDL__OpenGL_gluPickMatrix); /* prototype to pass -Wmissing-prototypes */
3608 XS(XS_SDL__OpenGL_gluPickMatrix)
3609 {
3610     dXSARGS;
3611     if (items != 5)
3612         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluPickMatrix(x, y, delx, dely, viewport)");
3613     {
3614         double  x = (double)SvNV(ST(0));
3615         double  y = (double)SvNV(ST(1));
3616         double  delx = (double)SvNV(ST(2));
3617         double  dely = (double)SvNV(ST(3));
3618         GLint*  viewport = INT2PTR(GLint *,SvIV(ST(4)));
3619 #line 2198 "OpenGL.xs"
3620                 gluPickMatrix(x,y,delx,dely,viewport);
3621 #line 3622 "OpenGL.c"
3622     }
3623     XSRETURN_EMPTY;
3624 }
3625
3626 XS(XS_SDL__OpenGL_gluOrtho2D); /* prototype to pass -Wmissing-prototypes */
3627 XS(XS_SDL__OpenGL_gluOrtho2D)
3628 {
3629     dXSARGS;
3630     if (items != 4)
3631         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluOrtho2D(left, right, bottom, top)");
3632     {
3633         double  left = (double)SvNV(ST(0));
3634         double  right = (double)SvNV(ST(1));
3635         double  bottom = (double)SvNV(ST(2));
3636         double  top = (double)SvNV(ST(3));
3637 #line 2207 "OpenGL.xs"
3638                 gluOrtho2D(left,right,bottom,top);
3639 #line 3640 "OpenGL.c"
3640     }
3641     XSRETURN_EMPTY;
3642 }
3643
3644 XS(XS_SDL__OpenGL_gluScaleImage); /* prototype to pass -Wmissing-prototypes */
3645 XS(XS_SDL__OpenGL_gluScaleImage)
3646 {
3647     dXSARGS;
3648     if (items != 9)
3649         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluScaleImage(format, widthin, heightin, typein, datain, widthout, heightout, typeout, dataout)");
3650     {
3651         GLenum  format = (GLenum)SvIV(ST(0));
3652         Uint32  widthin = (Uint32)SvUV(ST(1));
3653         Uint32  heightin = (Uint32)SvUV(ST(2));
3654         GLenum  typein = (GLenum)SvIV(ST(3));
3655         char *  datain = (char *)SvPV_nolen(ST(4));
3656         Uint32  widthout = (Uint32)SvUV(ST(5));
3657         Uint32  heightout = (Uint32)SvUV(ST(6));
3658         GLenum  typeout = (GLenum)SvIV(ST(7));
3659         char *  dataout = (char *)SvPV_nolen(ST(8));
3660         int     RETVAL;
3661         dXSTARG;
3662 #line 2221 "OpenGL.xs"
3663                 RETVAL = gluScaleImage(format,widthin,heightin,typein,datain,
3664                                 widthout,heightout,typeout,dataout);
3665 #line 3666 "OpenGL.c"
3666         XSprePUSH; PUSHi((IV)RETVAL);
3667     }
3668     XSRETURN(1);
3669 }
3670
3671 XS(XS_SDL__OpenGL_gluBuild1DMipmaps); /* prototype to pass -Wmissing-prototypes */
3672 XS(XS_SDL__OpenGL_gluBuild1DMipmaps)
3673 {
3674     dXSARGS;
3675     if (items != 6)
3676         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBuild1DMipmaps(target, internalFormat, width, format, type, data)");
3677     {
3678         GLenum  target = (GLenum)SvIV(ST(0));
3679         Sint32  internalFormat = (Sint32)SvIV(ST(1));
3680         Uint32  width = (Uint32)SvUV(ST(2));
3681         GLenum  format = (GLenum)SvIV(ST(3));
3682         GLenum  type = (GLenum)SvIV(ST(4));
3683         char *  data = (char *)SvPV_nolen(ST(5));
3684         int     RETVAL;
3685         dXSTARG;
3686 #line 2235 "OpenGL.xs"
3687                 RETVAL = gluBuild1DMipmaps(target,internalFormat,width,format,type,data);
3688 #line 3689 "OpenGL.c"
3689         XSprePUSH; PUSHi((IV)RETVAL);
3690     }
3691     XSRETURN(1);
3692 }
3693
3694 XS(XS_SDL__OpenGL_gluBuild2DMipmaps); /* prototype to pass -Wmissing-prototypes */
3695 XS(XS_SDL__OpenGL_gluBuild2DMipmaps)
3696 {
3697     dXSARGS;
3698     if (items != 7)
3699         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBuild2DMipmaps(target, internalFormat, width, height, format, type, data)");
3700     {
3701         GLenum  target = (GLenum)SvIV(ST(0));
3702         Sint32  internalFormat = (Sint32)SvIV(ST(1));
3703         Uint32  width = (Uint32)SvUV(ST(2));
3704         Uint32  height = (Uint32)SvUV(ST(3));
3705         GLenum  format = (GLenum)SvIV(ST(4));
3706         GLenum  type = (GLenum)SvIV(ST(5));
3707         char *  data = (char *)SvPV_nolen(ST(6));
3708         int     RETVAL;
3709         dXSTARG;
3710 #line 2249 "OpenGL.xs"
3711                 RETVAL = gluBuild2DMipmaps(target,internalFormat,width,height,format,type,data);
3712 #line 3713 "OpenGL.c"
3713         XSprePUSH; PUSHi((IV)RETVAL);
3714     }
3715     XSRETURN(1);
3716 }
3717
3718 #if HAVE_GLU_VERSION >= 12
3719 #define XSubPPtmpAAAF 1
3720
3721 XS(XS_SDL__OpenGL_gluBuild3DMipmaps); /* prototype to pass -Wmissing-prototypes */
3722 XS(XS_SDL__OpenGL_gluBuild3DMipmaps)
3723 {
3724     dXSARGS;
3725     if (items != 8)
3726         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBuild3DMipmaps(target, internalFormat, width, height, depth, format, type, data)");
3727     {
3728         GLenum  target = (GLenum)SvIV(ST(0));
3729         Sint32  internalFormat = (Sint32)SvIV(ST(1));
3730         Uint32  width = (Uint32)SvUV(ST(2));
3731         Uint32  height = (Uint32)SvUV(ST(3));
3732         Uint32  depth = (Uint32)SvUV(ST(4));
3733         GLenum  format = (GLenum)SvIV(ST(5));
3734         GLenum  type = (GLenum)SvIV(ST(6));
3735         char *  data = (char *)SvPV_nolen(ST(7));
3736         int     RETVAL;
3737         dXSTARG;
3738 #line 2266 "OpenGL.xs"
3739                 RETVAL = gluBuild3DMipmaps(target,internalFormat,width,height,depth,
3740                                 format,type,data);
3741 #line 3742 "OpenGL.c"
3742         XSprePUSH; PUSHi((IV)RETVAL);
3743     }
3744     XSRETURN(1);
3745 }
3746
3747 #else
3748 #define XSubPPtmpAAAG 1
3749
3750 XS(XS_SDL__OpenGL_gluBuild3DMipmaps); /* prototype to pass -Wmissing-prototypes */
3751 XS(XS_SDL__OpenGL_gluBuild3DMipmaps)
3752 {
3753     dXSARGS;
3754     if (items != 0)
3755         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBuild3DMipmaps()");
3756     {
3757 #line 2275 "OpenGL.xs"
3758                 Perl_croak (aTHX_ "SDL::OpenGL::Build3DMipmaps requires GLU 1.2");
3759 #line 3760 "OpenGL.c"
3760     }
3761     XSRETURN_EMPTY;
3762 }
3763
3764 #endif
3765 #if HAVE_GLU_VERSION >= 12
3766 #define XSubPPtmpAAAH 1
3767
3768 XS(XS_SDL__OpenGL_gluBuild1DMipmapLevels); /* prototype to pass -Wmissing-prototypes */
3769 XS(XS_SDL__OpenGL_gluBuild1DMipmapLevels)
3770 {
3771     dXSARGS;
3772     if (items != 9)
3773         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBuild1DMipmapLevels(target, internalFormat, width, format, type, level, base, max, data)");
3774     {
3775         GLenum  target = (GLenum)SvIV(ST(0));
3776         Sint32  internalFormat = (Sint32)SvIV(ST(1));
3777         Uint32  width = (Uint32)SvUV(ST(2));
3778         GLenum  format = (GLenum)SvIV(ST(3));
3779         GLenum  type = (GLenum)SvIV(ST(4));
3780         Sint32  level = (Sint32)SvIV(ST(5));
3781         Sint32  base = (Sint32)SvIV(ST(6));
3782         Sint32  max = (Sint32)SvIV(ST(7));
3783         char *  data = (char *)SvPV_nolen(ST(8));
3784         int     RETVAL;
3785         dXSTARG;
3786 #line 2292 "OpenGL.xs"
3787                 RETVAL = gluBuild1DMipmapLevels(target,internalFormat,width,
3788                                 format,type,level,base,max,data);
3789 #line 3790 "OpenGL.c"
3790         XSprePUSH; PUSHi((IV)RETVAL);
3791     }
3792     XSRETURN(1);
3793 }
3794
3795 #else
3796 #define XSubPPtmpAAAI 1
3797
3798 XS(XS_SDL__OpenGL_gluBuild1DMipmapLevels); /* prototype to pass -Wmissing-prototypes */
3799 XS(XS_SDL__OpenGL_gluBuild1DMipmapLevels)
3800 {
3801     dXSARGS;
3802     if (items != 0)
3803         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBuild1DMipmapLevels()");
3804     {
3805 #line 2301 "OpenGL.xs"
3806                 Perl_croak(aTHX_ "SDL::OpenGL::Build1DMipmapLevels requires GLU 1.2");
3807 #line 3808 "OpenGL.c"
3808     }
3809     XSRETURN_EMPTY;
3810 }
3811
3812 #endif
3813 #if HAVE_GLU_VERSION >= 12
3814 #define XSubPPtmpAAAJ 1
3815
3816 XS(XS_SDL__OpenGL_gluBuild2DMipmapLevels); /* prototype to pass -Wmissing-prototypes */
3817 XS(XS_SDL__OpenGL_gluBuild2DMipmapLevels)
3818 {
3819     dXSARGS;
3820     if (items != 10)
3821         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBuild2DMipmapLevels(target, internalFormat, width, height, format, type, level, base, max, data)");
3822     {
3823         GLenum  target = (GLenum)SvIV(ST(0));
3824         Sint32  internalFormat = (Sint32)SvIV(ST(1));
3825         Uint32  width = (Uint32)SvUV(ST(2));
3826         Uint32  height = (Uint32)SvUV(ST(3));
3827         GLenum  format = (GLenum)SvIV(ST(4));
3828         GLenum  type = (GLenum)SvIV(ST(5));
3829         Sint32  level = (Sint32)SvIV(ST(6));
3830         Sint32  base = (Sint32)SvIV(ST(7));
3831         Sint32  max = (Sint32)SvIV(ST(8));
3832         char *  data = (char *)SvPV_nolen(ST(9));
3833         int     RETVAL;
3834         dXSTARG;
3835 #line 2319 "OpenGL.xs"
3836                 RETVAL = gluBuild2DMipmapLevels(target,internalFormat,width,height,
3837                                 format,type,level,base,max,data);
3838 #line 3839 "OpenGL.c"
3839         XSprePUSH; PUSHi((IV)RETVAL);
3840     }
3841     XSRETURN(1);
3842 }
3843
3844 #else
3845 #define XSubPPtmpAAAK 1
3846
3847 XS(XS_SDL__OpenGL_gluBuild2DMipmapLevels); /* prototype to pass -Wmissing-prototypes */
3848 XS(XS_SDL__OpenGL_gluBuild2DMipmapLevels)
3849 {
3850     dXSARGS;
3851     if (items != 0)
3852         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBuild2DMipmapLevels()");
3853     {
3854 #line 2328 "OpenGL.xs"
3855                 Perl_croak(aTHX_ "SDL::OpenGL::Build2DMipmapLevels requires GLU 1.2");
3856 #line 3857 "OpenGL.c"
3857     }
3858     XSRETURN_EMPTY;
3859 }
3860
3861 #endif
3862 #if HAVE_GLU_VERSION >= 12
3863 #define XSubPPtmpAAAL 1
3864
3865 XS(XS_SDL__OpenGL_gluBuild3DMipmapLevels); /* prototype to pass -Wmissing-prototypes */
3866 XS(XS_SDL__OpenGL_gluBuild3DMipmapLevels)
3867 {
3868     dXSARGS;
3869     if (items != 11)
3870         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBuild3DMipmapLevels(target, internalFormat, width, height, depth, format, type, level, base, max, data)");
3871     {
3872         GLenum  target = (GLenum)SvIV(ST(0));
3873         Sint32  internalFormat = (Sint32)SvIV(ST(1));
3874         Uint32  width = (Uint32)SvUV(ST(2));
3875         Uint32  height = (Uint32)SvUV(ST(3));
3876         Uint32  depth = (Uint32)SvUV(ST(4));
3877         GLenum  format = (GLenum)SvIV(ST(5));
3878         GLenum  type = (GLenum)SvIV(ST(6));
3879         Sint32  level = (Sint32)SvIV(ST(7));
3880         Sint32  base = (Sint32)SvIV(ST(8));
3881         Sint32  max = (Sint32)SvIV(ST(9));
3882         char *  data = (char *)SvPV_nolen(ST(10));
3883         int     RETVAL;
3884         dXSTARG;
3885 #line 2347 "OpenGL.xs"
3886                 RETVAL = gluBuild3DMipmapLevels(target,internalFormat,width,height,depth,
3887                                 format,type,level,base,max,data);
3888 #line 3889 "OpenGL.c"
3889         XSprePUSH; PUSHi((IV)RETVAL);
3890     }
3891     XSRETURN(1);
3892 }
3893
3894 #else
3895 #define XSubPPtmpAAAM 1
3896
3897 XS(XS_SDL__OpenGL_gluBuild3DMipmapLevels); /* prototype to pass -Wmissing-prototypes */
3898 XS(XS_SDL__OpenGL_gluBuild3DMipmapLevels)
3899 {
3900     dXSARGS;
3901     if (items != 0)
3902         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBuild3DMipmapLevels()");
3903     {
3904 #line 2356 "OpenGL.xs"
3905                 Perl_croak(aTHX_ "SDL::OpenGL::Build3DMipmapLevels requires GLU 1.2");
3906 #line 3907 "OpenGL.c"
3907     }
3908     XSRETURN_EMPTY;
3909 }
3910
3911 #endif
3912 XS(XS_SDL__OpenGL_gluErrorString); /* prototype to pass -Wmissing-prototypes */
3913 XS(XS_SDL__OpenGL_gluErrorString)
3914 {
3915     dXSARGS;
3916     if (items != 1)
3917         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluErrorString(code)");
3918     {
3919         GLenum  code = (GLenum)SvIV(ST(0));
3920         char *  RETVAL;
3921         dXSTARG;
3922 #line 2364 "OpenGL.xs"
3923                 RETVAL = (char*)gluErrorString(code);
3924 #line 3925 "OpenGL.c"
3925         sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
3926     }
3927     XSRETURN(1);
3928 }
3929
3930 XS(XS_SDL__OpenGL_gluNewNurbsRenderer); /* prototype to pass -Wmissing-prototypes */
3931 XS(XS_SDL__OpenGL_gluNewNurbsRenderer)
3932 {
3933     dXSARGS;
3934     if (items != 0)
3935         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluNewNurbsRenderer()");
3936     {
3937         GLUnurbsObj *   RETVAL;
3938         dXSTARG;
3939 #line 2371 "OpenGL.xs"
3940                 RETVAL = gluNewNurbsRenderer();
3941 #line 3942 "OpenGL.c"
3942         XSprePUSH; PUSHi(PTR2IV(RETVAL));
3943     }
3944     XSRETURN(1);
3945 }
3946
3947 XS(XS_SDL__OpenGL_gluDeleteNurbsRenderer); /* prototype to pass -Wmissing-prototypes */
3948 XS(XS_SDL__OpenGL_gluDeleteNurbsRenderer)
3949 {
3950     dXSARGS;
3951     if (items != 1)
3952         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluDeleteNurbsRenderer(obj)");
3953     {
3954         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
3955 #line 2379 "OpenGL.xs"
3956                 gluDeleteNurbsRenderer(obj);
3957 #line 3958 "OpenGL.c"
3958     }
3959     XSRETURN_EMPTY;
3960 }
3961
3962 XS(XS_SDL__OpenGL_gluNurbsProperty); /* prototype to pass -Wmissing-prototypes */
3963 XS(XS_SDL__OpenGL_gluNurbsProperty)
3964 {
3965     dXSARGS;
3966     if (items != 3)
3967         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluNurbsProperty(obj, property, value)");
3968     {
3969         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
3970         GLenum  property = (GLenum)SvIV(ST(1));
3971         double  value = (double)SvNV(ST(2));
3972 #line 2387 "OpenGL.xs"
3973                 gluNurbsProperty(obj,property,(float)value);
3974 #line 3975 "OpenGL.c"
3975     }
3976     XSRETURN_EMPTY;
3977 }
3978
3979 XS(XS_SDL__OpenGL_gluLoadSamplingMatrices); /* prototype to pass -Wmissing-prototypes */
3980 XS(XS_SDL__OpenGL_gluLoadSamplingMatrices)
3981 {
3982     dXSARGS;
3983     if (items != 4)
3984         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluLoadSamplingMatrices(obj, mm, pm, vp)");
3985     {
3986         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
3987         char *  mm = (char *)SvPV_nolen(ST(1));
3988         char *  pm = (char *)SvPV_nolen(ST(2));
3989         char *  vp = (char *)SvPV_nolen(ST(3));
3990 #line 2396 "OpenGL.xs"
3991                 gluLoadSamplingMatrices(obj,(GLfloat*)mm,(GLfloat*)pm,(GLint*)vp);
3992 #line 3993 "OpenGL.c"
3993     }
3994     XSRETURN_EMPTY;
3995 }
3996
3997 XS(XS_SDL__OpenGL_gluGetNurbsProperty); /* prototype to pass -Wmissing-prototypes */
3998 XS(XS_SDL__OpenGL_gluGetNurbsProperty)
3999 {
4000     dXSARGS;
4001     if (items != 2)
4002         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluGetNurbsProperty(obj, property)");
4003     {
4004         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4005         GLenum  property = (GLenum)SvIV(ST(1));
4006         double  RETVAL;
4007         dXSTARG;
4008 #line 2403 "OpenGL.xs"
4009                 float f;
4010                 gluGetNurbsProperty(obj,property,&f);
4011                 RETVAL = (double)f;
4012 #line 4013 "OpenGL.c"
4013         XSprePUSH; PUSHn((double)RETVAL);
4014     }
4015     XSRETURN(1);
4016 }
4017
4018 XS(XS_SDL__OpenGL_gluNurbsCallback); /* prototype to pass -Wmissing-prototypes */
4019 XS(XS_SDL__OpenGL_gluNurbsCallback)
4020 {
4021     dXSARGS;
4022     if (items != 3)
4023         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluNurbsCallback(obj, which, cb)");
4024     {
4025         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4026         GLenum  which = (GLenum)SvIV(ST(1));
4027         SV *    cb = ST(2);
4028 #line 2415 "OpenGL.xs"
4029                 switch(which) {
4030                         case GLU_ERROR:
4031                                 sdl_perl_nurbs_error_hook = cb;
4032                                 gluNurbsCallback(obj,GLU_ERROR,(GLvoid*)sdl_perl_nurbs_error_callback);
4033                                 break;
4034 #ifdef GLU_NURBS_BEGIN
4035                         case GLU_NURBS_BEGIN:
4036                         case GLU_NURBS_BEGIN_DATA:
4037                                 gluNurbsCallbackData(obj,(void*)cb);
4038                                 gluNurbsCallback(obj,GLU_NURBS_BEGIN_DATA,
4039                                         (GLvoid*)sdl_perl_nurbs_being_callback);
4040                                 break;
4041                         case GLU_NURBS_TEXTURE_COORD:
4042                         case GLU_NURBS_TEXTURE_COORD_DATA:
4043                                 gluNurbsCallbackData(obj,(void*)cb);
4044                                 gluNurbsCallback(obj,GLU_NURBS_TEXTURE_COORD_DATA,
4045                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
4046                                 break;
4047                         case GLU_NURBS_COLOR:
4048                         case GLU_NURBS_COLOR_DATA:
4049                                 gluNurbsCallbackData(obj,(void*)cb);
4050                                 gluNurbsCallback(obj,GLU_NURBS_COLOR_DATA,
4051                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
4052                                 break;
4053                         case GLU_NURBS_NORMAL:
4054                         case GLU_NURBS_NORMAL_DATA:
4055                                 gluNurbsCallbackData(obj,(void*)cb);
4056                                 gluNurbsCallback(obj,GLU_NURBS_NORMAL_DATA,
4057                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
4058                                 break;
4059                         case GLU_NURBS_VERTEX:
4060                         case GLU_NURBS_VERTEX_DATA:
4061                                 gluNurbsCallbackData(obj,(void*)cb);
4062                                 gluNurbsCallback(obj,GLU_NURBS_VERTEX_DATA,
4063                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
4064                                 break;
4065                         case GLU_NURBS_END:
4066                         case GLU_NURBS_END_DATA:
4067                                 gluNurbsCallbackData(obj,(void*)cb);
4068                                 gluNurbsCallback(obj,GLU_NURBS_END_DATA,
4069                                         (GLvoid*)sdl_perl_nurbs_end_callback);
4070                                 break;
4071 #endif
4072                         default:
4073                                 Perl_croak(aTHX_ "SDL::OpenGL::NurbsCallback - invalid type");
4074                 }
4075 #line 4076 "OpenGL.c"
4076     }
4077     XSRETURN_EMPTY;
4078 }
4079
4080 XS(XS_SDL__OpenGL_gluNurbsCallbackData); /* prototype to pass -Wmissing-prototypes */
4081 XS(XS_SDL__OpenGL_gluNurbsCallbackData)
4082 {
4083     dXSARGS;
4084     if (items != 2)
4085         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluNurbsCallbackData(obj, cb)");
4086     {
4087         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4088         SV *    cb = ST(1);
4089 #line 2467 "OpenGL.xs"
4090                 gluNurbsCallbackData(obj,(void*)cb);
4091 #line 4092 "OpenGL.c"
4092     }
4093     XSRETURN_EMPTY;
4094 }
4095
4096 XS(XS_SDL__OpenGL_gluBeginSurface); /* prototype to pass -Wmissing-prototypes */
4097 XS(XS_SDL__OpenGL_gluBeginSurface)
4098 {
4099     dXSARGS;
4100     if (items != 1)
4101         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBeginSurface(obj)");
4102     {
4103         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4104 #line 2473 "OpenGL.xs"
4105                 gluBeginSurface(obj);
4106 #line 4107 "OpenGL.c"
4107     }
4108     XSRETURN_EMPTY;
4109 }
4110
4111 XS(XS_SDL__OpenGL_gluEndSurface); /* prototype to pass -Wmissing-prototypes */
4112 XS(XS_SDL__OpenGL_gluEndSurface)
4113 {
4114     dXSARGS;
4115     if (items != 1)
4116         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluEndSurface(obj)");
4117     {
4118         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4119 #line 2479 "OpenGL.xs"
4120                 gluEndSurface(obj);
4121 #line 4122 "OpenGL.c"
4122     }
4123     XSRETURN_EMPTY;
4124 }
4125
4126 XS(XS_SDL__OpenGL_gluNurbsSurface); /* prototype to pass -Wmissing-prototypes */
4127 XS(XS_SDL__OpenGL_gluNurbsSurface)
4128 {
4129     dXSARGS;
4130     if (items != 11)
4131         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluNurbsSurface(obj, uknot_count, uknot, vknot_count, vknot, u_stride, v_stride, ctlarray, uorder, vorder, type)");
4132     {
4133         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4134         Sint32  uknot_count = (Sint32)SvIV(ST(1));
4135         char *  uknot = (char *)SvPV_nolen(ST(2));
4136         Sint32  vknot_count = (Sint32)SvIV(ST(3));
4137         char *  vknot = (char *)SvPV_nolen(ST(4));
4138         Sint32  u_stride = (Sint32)SvIV(ST(5));
4139         Sint32  v_stride = (Sint32)SvIV(ST(6));
4140         char *  ctlarray = (char *)SvPV_nolen(ST(7));
4141         Sint32  uorder = (Sint32)SvIV(ST(8));
4142         Sint32  vorder = (Sint32)SvIV(ST(9));
4143         GLenum  type = (GLenum)SvIV(ST(10));
4144 #line 2495 "OpenGL.xs"
4145                 gluNurbsSurface(obj,uknot_count,(GLfloat*)uknot,vknot_count,(GLfloat*)vknot,
4146                         u_stride,v_stride,(GLfloat*)ctlarray,uorder,vorder,type);
4147 #line 4148 "OpenGL.c"
4148     }
4149     XSRETURN_EMPTY;
4150 }
4151
4152 XS(XS_SDL__OpenGL_gluBeginCurve); /* prototype to pass -Wmissing-prototypes */
4153 XS(XS_SDL__OpenGL_gluBeginCurve)
4154 {
4155     dXSARGS;
4156     if (items != 1)
4157         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBeginCurve(obj)");
4158     {
4159         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4160 #line 2502 "OpenGL.xs"
4161                 gluBeginCurve(obj);
4162 #line 4163 "OpenGL.c"
4163     }
4164     XSRETURN_EMPTY;
4165 }
4166
4167 XS(XS_SDL__OpenGL_gluEndCurve); /* prototype to pass -Wmissing-prototypes */
4168 XS(XS_SDL__OpenGL_gluEndCurve)
4169 {
4170     dXSARGS;
4171     if (items != 1)
4172         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluEndCurve(obj)");
4173     {
4174         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4175 #line 2508 "OpenGL.xs"
4176                 gluEndCurve(obj);
4177 #line 4178 "OpenGL.c"
4178     }
4179     XSRETURN_EMPTY;
4180 }
4181
4182 XS(XS_SDL__OpenGL_gluNurbsCurve); /* prototype to pass -Wmissing-prototypes */
4183 XS(XS_SDL__OpenGL_gluNurbsCurve)
4184 {
4185     dXSARGS;
4186     if (items != 7)
4187         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluNurbsCurve(obj, uknot_count, uknot, u_stride, ctlarray, uorder, type)");
4188     {
4189         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4190         Sint32  uknot_count = (Sint32)SvIV(ST(1));
4191         char *  uknot = (char *)SvPV_nolen(ST(2));
4192         Sint32  u_stride = (Sint32)SvIV(ST(3));
4193         char *  ctlarray = (char *)SvPV_nolen(ST(4));
4194         Sint32  uorder = (Sint32)SvIV(ST(5));
4195         GLenum  type = (GLenum)SvIV(ST(6));
4196 #line 2520 "OpenGL.xs"
4197                 gluNurbsCurve(obj,uknot_count,(GLfloat*)uknot,u_stride,(GLfloat*)ctlarray,
4198                         uorder,type);
4199 #line 4200 "OpenGL.c"
4200     }
4201     XSRETURN_EMPTY;
4202 }
4203
4204 XS(XS_SDL__OpenGL_gluBeginTrim); /* prototype to pass -Wmissing-prototypes */
4205 XS(XS_SDL__OpenGL_gluBeginTrim)
4206 {
4207     dXSARGS;
4208     if (items != 1)
4209         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluBeginTrim(obj)");
4210     {
4211         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4212 #line 2527 "OpenGL.xs"
4213                 gluBeginTrim(obj);
4214 #line 4215 "OpenGL.c"
4215     }
4216     XSRETURN_EMPTY;
4217 }
4218
4219 XS(XS_SDL__OpenGL_gluEndTrim); /* prototype to pass -Wmissing-prototypes */
4220 XS(XS_SDL__OpenGL_gluEndTrim)
4221 {
4222     dXSARGS;
4223     if (items != 1)
4224         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluEndTrim(obj)");
4225     {
4226         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4227 #line 2533 "OpenGL.xs"
4228                 gluEndTrim(obj);
4229 #line 4230 "OpenGL.c"
4230     }
4231     XSRETURN_EMPTY;
4232 }
4233
4234 XS(XS_SDL__OpenGL_gluPwlCurve); /* prototype to pass -Wmissing-prototypes */
4235 XS(XS_SDL__OpenGL_gluPwlCurve)
4236 {
4237     dXSARGS;
4238     if (items != 5)
4239         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluPwlCurve(obj, count, array, stride, type)");
4240     {
4241         GLUnurbsObj *   obj = INT2PTR(GLUnurbsObj *,SvIV(ST(0)));
4242         Sint32  count = (Sint32)SvIV(ST(1));
4243         char *  array = (char *)SvPV_nolen(ST(2));
4244         Sint32  stride = (Sint32)SvIV(ST(3));
4245         GLenum  type = (GLenum)SvIV(ST(4));
4246 #line 2543 "OpenGL.xs"
4247                 gluPwlCurve(obj,count,(GLfloat*)array,stride,type);
4248 #line 4249 "OpenGL.c"
4249     }
4250     XSRETURN_EMPTY;
4251 }
4252
4253 XS(XS_SDL__OpenGL_gluUnProject); /* prototype to pass -Wmissing-prototypes */
4254 XS(XS_SDL__OpenGL_gluUnProject)
4255 {
4256     dXSARGS;
4257     if (items != 6)
4258         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluUnProject(winx, winy, winz, mm, pm, vp)");
4259     {
4260         double  winx = (double)SvNV(ST(0));
4261         double  winy = (double)SvNV(ST(1));
4262         double  winz = (double)SvNV(ST(2));
4263         char *  mm = (char *)SvPV_nolen(ST(3));
4264         char *  pm = (char *)SvPV_nolen(ST(4));
4265         char *  vp = (char *)SvPV_nolen(ST(5));
4266         AV *    RETVAL;
4267 #line 2554 "OpenGL.xs"
4268                 GLdouble objx, objy, objz;
4269                 RETVAL = newAV();
4270                 av_push(RETVAL,newSViv(gluUnProject(winx,winy,winz,(GLdouble*)mm,
4271                         (GLdouble*)pm,(GLint*)vp,&objx,&objy,&objz)));
4272                 av_push(RETVAL,newSVnv((double)objx));
4273                 av_push(RETVAL,newSVnv((double)objy));
4274                 av_push(RETVAL,newSVnv((double)objz));
4275 #line 4276 "OpenGL.c"
4276         ST(0) = newRV((SV*)RETVAL);
4277         sv_2mortal(ST(0));
4278     }
4279     XSRETURN(1);
4280 }
4281
4282 #ifdef GL_VERSION_1_3
4283 #define XSubPPtmpAAAN 1
4284
4285 XS(XS_SDL__OpenGL_gluUnProject4); /* prototype to pass -Wmissing-prototypes */
4286 XS(XS_SDL__OpenGL_gluUnProject4)
4287 {
4288     dXSARGS;
4289     if (items != 9)
4290         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluUnProject4(winx, winy, winz, clipw, mm, pm, vp, n, f)");
4291     {
4292         double  winx = (double)SvNV(ST(0));
4293         double  winy = (double)SvNV(ST(1));
4294         double  winz = (double)SvNV(ST(2));
4295         double  clipw = (double)SvNV(ST(3));
4296         char *  mm = (char *)SvPV_nolen(ST(4));
4297         char *  pm = (char *)SvPV_nolen(ST(5));
4298         char *  vp = (char *)SvPV_nolen(ST(6));
4299         double  n = (double)SvNV(ST(7));
4300         double  f = (double)SvNV(ST(8));
4301         AV *    RETVAL;
4302 #line 2579 "OpenGL.xs"
4303                 GLdouble objx, objy, objz, objw;
4304                 RETVAL = newAV();
4305                 av_push(RETVAL,newSViv(gluUnProject4(winx,winy,winz,clipw,(GLdouble*)mm,
4306                         (GLdouble*)pm,(GLint*)vp,(GLclampd)n,(GLclampd)f,
4307                         &objx,&objy,&objz,&objw)));
4308                 av_push(RETVAL,newSVnv((double)objx));
4309                 av_push(RETVAL,newSVnv((double)objy));
4310                 av_push(RETVAL,newSVnv((double)objz));
4311                 av_push(RETVAL,newSVnv((double)objw));
4312 #line 4313 "OpenGL.c"
4313         ST(0) = newRV((SV*)RETVAL);
4314         sv_2mortal(ST(0));
4315     }
4316     XSRETURN(1);
4317 }
4318
4319 #endif // GL_VERSION_1_3
4320 XS(XS_SDL__OpenGL_gluProject); /* prototype to pass -Wmissing-prototypes */
4321 XS(XS_SDL__OpenGL_gluProject)
4322 {
4323     dXSARGS;
4324     if (items != 6)
4325         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluProject(objx, objy, objz, mm, pm, vp)");
4326     {
4327         double  objx = (double)SvNV(ST(0));
4328         double  objy = (double)SvNV(ST(1));
4329         double  objz = (double)SvNV(ST(2));
4330         char *  mm = (char *)SvPV_nolen(ST(3));
4331         char *  pm = (char *)SvPV_nolen(ST(4));
4332         char *  vp = (char *)SvPV_nolen(ST(5));
4333         AV *    RETVAL;
4334 #line 2602 "OpenGL.xs"
4335                 GLdouble winx, winy, winz;
4336                 RETVAL = newAV();
4337                 av_push(RETVAL,newSViv(gluUnProject(objx,objy,objz,(GLdouble*)mm,
4338                         (GLdouble*)pm,(GLint*)vp,&winx,&winy,&winz)));
4339                 av_push(RETVAL,newSVnv((double)winx));
4340                 av_push(RETVAL,newSVnv((double)winy));
4341                 av_push(RETVAL,newSVnv((double)winz));
4342 #line 4343 "OpenGL.c"
4343         ST(0) = newRV((SV*)RETVAL);
4344         sv_2mortal(ST(0));
4345     }
4346     XSRETURN(1);
4347 }
4348
4349 #ifdef GL_VERSION_1_2
4350 #define XSubPPtmpAAAO 1
4351
4352 XS(XS_SDL__OpenGL_gluNewTess); /* prototype to pass -Wmissing-prototypes */
4353 XS(XS_SDL__OpenGL_gluNewTess)
4354 {
4355     dXSARGS;
4356     if (items != 0)
4357         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluNewTess()");
4358     {
4359         GLUtesselator * RETVAL;
4360         dXSTARG;
4361 #line 2617 "OpenGL.xs"
4362                 RETVAL = gluNewTess();
4363 #line 4364 "OpenGL.c"
4364         XSprePUSH; PUSHi(PTR2IV(RETVAL));
4365     }
4366     XSRETURN(1);
4367 }
4368
4369 XS(XS_SDL__OpenGL_gluTessCallback); /* prototype to pass -Wmissing-prototypes */
4370 XS(XS_SDL__OpenGL_gluTessCallback)
4371 {
4372     dXSARGS;
4373     if (items != 2)
4374         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluTessCallback(tess, type)");
4375     {
4376         GLUtesselator * tess = INT2PTR(GLUtesselator *,SvIV(ST(0)));
4377         GLenum  type = (GLenum)SvIV(ST(1));
4378 #line 2626 "OpenGL.xs"
4379                 switch(type) {
4380                         case GLU_TESS_BEGIN:
4381                         case GLU_TESS_BEGIN_DATA:
4382                                 gluTessCallback(tess,GLU_TESS_BEGIN_DATA,
4383                                         (GLvoid*)sdl_perl_tess_begin_callback);
4384                                 break;
4385
4386                         case GLU_TESS_EDGE_FLAG:
4387                         case GLU_TESS_EDGE_FLAG_DATA:
4388                                 gluTessCallback(tess,GLU_TESS_EDGE_FLAG_DATA,
4389                                         (GLvoid*)sdl_perl_tess_edge_flag_callback);
4390                                 break;
4391
4392                         case GLU_TESS_VERTEX:
4393                         case GLU_TESS_VERTEX_DATA:
4394                                 gluTessCallback(tess,GLU_TESS_VERTEX_DATA,
4395                                         (GLvoid*)sdl_perl_tess_vertex_callback);
4396                                 break;
4397
4398                         case GLU_TESS_END:
4399                         case GLU_TESS_END_DATA:
4400                                 gluTessCallback(tess,GLU_TESS_END_DATA,
4401                                         (GLvoid*)sdl_perl_tess_end_callback);
4402                                 break;
4403
4404                         case GLU_TESS_COMBINE:
4405                         case GLU_TESS_COMBINE_DATA:
4406                                 gluTessCallback(tess,GLU_TESS_COMBINE_DATA,
4407                                         (GLvoid*)sdl_perl_tess_combine_callback);
4408                                 break;
4409
4410                         case GLU_TESS_ERROR:
4411                         case GLU_TESS_ERROR_DATA:
4412                                 gluTessCallback(tess,GLU_TESS_ERROR_DATA,
4413                                         (GLvoid*)sdl_perl_tess_error_callback);
4414                                 break;
4415                 }
4416 #line 4417 "OpenGL.c"
4417     }
4418     XSRETURN_EMPTY;
4419 }
4420
4421 XS(XS_SDL__OpenGL_gluTessProperty); /* prototype to pass -Wmissing-prototypes */
4422 XS(XS_SDL__OpenGL_gluTessProperty)
4423 {
4424     dXSARGS;
4425     if (items != 3)
4426         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluTessProperty(tessobj, property, value)");
4427     {
4428         GLUtesselator * tessobj = INT2PTR(GLUtesselator *,SvIV(ST(0)));
4429         Uint32  property = (Uint32)SvUV(ST(1));
4430         double  value = (double)SvNV(ST(2));
4431 #line 2670 "OpenGL.xs"
4432                 gluTessProperty(tessobj,property,value);
4433 #line 4434 "OpenGL.c"
4434     }
4435     XSRETURN_EMPTY;
4436 }
4437
4438 XS(XS_SDL__OpenGL_gluGetTessProperty); /* prototype to pass -Wmissing-prototypes */
4439 XS(XS_SDL__OpenGL_gluGetTessProperty)
4440 {
4441     dXSARGS;
4442     if (items != 2)
4443         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluGetTessProperty(tessobj, property)");
4444     {
4445         GLUtesselator * tessobj = INT2PTR(GLUtesselator *,SvIV(ST(0)));
4446         Uint32  property = (Uint32)SvUV(ST(1));
4447         double  RETVAL;
4448         dXSTARG;
4449 #line 2677 "OpenGL.xs"
4450                 gluGetTessProperty(tessobj,property,&RETVAL);
4451 #line 4452 "OpenGL.c"
4452         XSprePUSH; PUSHn((double)RETVAL);
4453     }
4454     XSRETURN(1);
4455 }
4456
4457 XS(XS_SDL__OpenGL_gluTessNormal); /* prototype to pass -Wmissing-prototypes */
4458 XS(XS_SDL__OpenGL_gluTessNormal)
4459 {
4460     dXSARGS;
4461     if (items != 4)
4462         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluTessNormal(tessobj, x, y, z)");
4463     {
4464         GLUtesselator * tessobj = INT2PTR(GLUtesselator *,SvIV(ST(0)));
4465         double  x = (double)SvNV(ST(1));
4466         double  y = (double)SvNV(ST(2));
4467         double  z = (double)SvNV(ST(3));
4468 #line 2688 "OpenGL.xs"
4469                 gluTessNormal(tessobj,x,y,z);
4470 #line 4471 "OpenGL.c"
4471     }
4472     XSRETURN_EMPTY;
4473 }
4474
4475 XS(XS_SDL__OpenGL_gluTessBeginPolygon); /* prototype to pass -Wmissing-prototypes */
4476 XS(XS_SDL__OpenGL_gluTessBeginPolygon)
4477 {
4478     dXSARGS;
4479     if (items != 2)
4480         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluTessBeginPolygon(tessobj, cb)");
4481     {
4482         GLUtesselator * tessobj = INT2PTR(GLUtesselator *,SvIV(ST(0)));
4483         SV *    cb = ST(1);
4484 #line 2695 "OpenGL.xs"
4485                 gluTessBeginPolygon(tessobj,cb);
4486 #line 4487 "OpenGL.c"
4487     }
4488     XSRETURN_EMPTY;
4489 }
4490
4491 XS(XS_SDL__OpenGL_gluTessEndPolygon); /* prototype to pass -Wmissing-prototypes */
4492 XS(XS_SDL__OpenGL_gluTessEndPolygon)
4493 {
4494     dXSARGS;
4495     if (items != 1)
4496         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluTessEndPolygon(tessobj)");
4497     {
4498         GLUtesselator * tessobj = INT2PTR(GLUtesselator *,SvIV(ST(0)));
4499 #line 2701 "OpenGL.xs"
4500                 gluTessEndPolygon(tessobj);
4501 #line 4502 "OpenGL.c"
4502     }
4503     XSRETURN_EMPTY;
4504 }
4505
4506 XS(XS_SDL__OpenGL_gluTessBeginContour); /* prototype to pass -Wmissing-prototypes */
4507 XS(XS_SDL__OpenGL_gluTessBeginContour)
4508 {
4509     dXSARGS;
4510     if (items != 1)
4511         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluTessBeginContour(tessobj)");
4512     {
4513         GLUtesselator * tessobj = INT2PTR(GLUtesselator *,SvIV(ST(0)));
4514 #line 2707 "OpenGL.xs"
4515                 gluTessBeginContour(tessobj);
4516 #line 4517 "OpenGL.c"
4517     }
4518     XSRETURN_EMPTY;
4519 }
4520
4521 XS(XS_SDL__OpenGL_gluTessEndContour); /* prototype to pass -Wmissing-prototypes */
4522 XS(XS_SDL__OpenGL_gluTessEndContour)
4523 {
4524     dXSARGS;
4525     if (items != 1)
4526         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluTessEndContour(tessobj)");
4527     {
4528         GLUtesselator * tessobj = INT2PTR(GLUtesselator *,SvIV(ST(0)));
4529 #line 2713 "OpenGL.xs"
4530                 gluTessEndContour(tessobj);
4531 #line 4532 "OpenGL.c"
4532     }
4533     XSRETURN_EMPTY;
4534 }
4535
4536 XS(XS_SDL__OpenGL_gluDeleteTess); /* prototype to pass -Wmissing-prototypes */
4537 XS(XS_SDL__OpenGL_gluDeleteTess)
4538 {
4539     dXSARGS;
4540     if (items != 1)
4541         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluDeleteTess(tessobj)");
4542     {
4543         GLUtesselator * tessobj = INT2PTR(GLUtesselator *,SvIV(ST(0)));
4544 #line 2719 "OpenGL.xs"
4545                 gluDeleteTess(tessobj);
4546 #line 4547 "OpenGL.c"
4547     }
4548     XSRETURN_EMPTY;
4549 }
4550
4551 XS(XS_SDL__OpenGL_gluTessVertex); /* prototype to pass -Wmissing-prototypes */
4552 XS(XS_SDL__OpenGL_gluTessVertex)
4553 {
4554     dXSARGS;
4555     if (items != 3)
4556         Perl_croak(aTHX_ "Usage: SDL::OpenGL::gluTessVertex(tessobj, coords, vd)");
4557     {
4558         GLUtesselator * tessobj = INT2PTR(GLUtesselator *,SvIV(ST(0)));
4559         char *  coords = (char *)SvPV_nolen(ST(1));
4560         char *  vd = (char *)SvPV_nolen(ST(2));
4561 #line 2727 "OpenGL.xs"
4562                 gluTessVertex(tessobj,(GLdouble*)coords,vd);
4563 #line 4564 "OpenGL.c"
4564     }
4565     XSRETURN_EMPTY;
4566 }
4567
4568 #endif
4569 #endif
4570 #ifdef __cplusplus
4571 extern "C"
4572 #endif
4573 XS(boot_SDL__OpenGL); /* prototype to pass -Wmissing-prototypes */
4574 XS(boot_SDL__OpenGL)
4575 {
4576     dXSARGS;
4577     char* file = __FILE__;
4578
4579     XS_VERSION_BOOTCHECK ;
4580
4581 #if XSubPPtmpAAAA
4582         newXS("SDL::OpenGL::glClearColor", XS_SDL__OpenGL_glClearColor, file);
4583         newXS("SDL::OpenGL::glClearIndex", XS_SDL__OpenGL_glClearIndex, file);
4584         newXS("SDL::OpenGL::glClearDepth", XS_SDL__OpenGL_glClearDepth, file);
4585         newXS("SDL::OpenGL::glClearStencil", XS_SDL__OpenGL_glClearStencil, file);
4586         newXS("SDL::OpenGL::glClearAccum", XS_SDL__OpenGL_glClearAccum, file);
4587         newXS("SDL::OpenGL::glClear", XS_SDL__OpenGL_glClear, file);
4588         newXS("SDL::OpenGL::glFlush", XS_SDL__OpenGL_glFlush, file);
4589         newXS("SDL::OpenGL::glFinish", XS_SDL__OpenGL_glFinish, file);
4590         newXS("SDL::OpenGL::glRect", XS_SDL__OpenGL_glRect, file);
4591         newXS("SDL::OpenGL::glVertex", XS_SDL__OpenGL_glVertex, file);
4592         newXS("SDL::OpenGL::glBegin", XS_SDL__OpenGL_glBegin, file);
4593         newXS("SDL::OpenGL::glEnd", XS_SDL__OpenGL_glEnd, file);
4594         newXS("SDL::OpenGL::glEnable", XS_SDL__OpenGL_glEnable, file);
4595         newXS("SDL::OpenGL::glDisable", XS_SDL__OpenGL_glDisable, file);
4596         newXS("SDL::OpenGL::glGet", XS_SDL__OpenGL_glGet, file);
4597         newXS("SDL::OpenGL::glIsEnabled", XS_SDL__OpenGL_glIsEnabled, file);
4598         newXS("SDL::OpenGL::glPointSize", XS_SDL__OpenGL_glPointSize, file);
4599         newXS("SDL::OpenGL::glLineWidth", XS_SDL__OpenGL_glLineWidth, file);
4600         newXS("SDL::OpenGL::glLineStipple", XS_SDL__OpenGL_glLineStipple, file);
4601         newXS("SDL::OpenGL::glPolygonMode", XS_SDL__OpenGL_glPolygonMode, file);
4602         newXS("SDL::OpenGL::glFrontFace", XS_SDL__OpenGL_glFrontFace, file);
4603         newXS("SDL::OpenGL::glCullFace", XS_SDL__OpenGL_glCullFace, file);
4604         newXS("SDL::OpenGL::glPolygonStipple", XS_SDL__OpenGL_glPolygonStipple, file);
4605         newXS("SDL::OpenGL::glEdgeFlag", XS_SDL__OpenGL_glEdgeFlag, file);
4606         newXS("SDL::OpenGL::glNormal", XS_SDL__OpenGL_glNormal, file);
4607         newXS("SDL::OpenGL::glEnableClientState", XS_SDL__OpenGL_glEnableClientState, file);
4608         newXS("SDL::OpenGL::glDisableClientState", XS_SDL__OpenGL_glDisableClientState, file);
4609         newXS("SDL::OpenGL::glVertexPointer", XS_SDL__OpenGL_glVertexPointer, file);
4610         newXS("SDL::OpenGL::glColorPointer", XS_SDL__OpenGL_glColorPointer, file);
4611         newXS("SDL::OpenGL::glNormalPointer", XS_SDL__OpenGL_glNormalPointer, file);
4612         newXS("SDL::OpenGL::glTexCoordPointer", XS_SDL__OpenGL_glTexCoordPointer, file);
4613         newXS("SDL::OpenGL::glEdgeFlagPointer", XS_SDL__OpenGL_glEdgeFlagPointer, file);
4614         newXS("SDL::OpenGL::glArrayElement", XS_SDL__OpenGL_glArrayElement, file);
4615         newXS("SDL::OpenGL::glDrawElements", XS_SDL__OpenGL_glDrawElements, file);
4616         newXS("SDL::OpenGL::glDrawRangeElements", XS_SDL__OpenGL_glDrawRangeElements, file);
4617         newXS("SDL::OpenGL::glDrawArrays", XS_SDL__OpenGL_glDrawArrays, file);
4618         newXS("SDL::OpenGL::glInterleavedArrays", XS_SDL__OpenGL_glInterleavedArrays, file);
4619         newXS("SDL::OpenGL::glPushAttrib", XS_SDL__OpenGL_glPushAttrib, file);
4620         newXS("SDL::OpenGL::glPopAttrib", XS_SDL__OpenGL_glPopAttrib, file);
4621         newXS("SDL::OpenGL::glPushClientAttrib", XS_SDL__OpenGL_glPushClientAttrib, file);
4622         newXS("SDL::OpenGL::glPopClientAttrib", XS_SDL__OpenGL_glPopClientAttrib, file);
4623         newXS("SDL::OpenGL::glMatrixMode", XS_SDL__OpenGL_glMatrixMode, file);
4624         newXS("SDL::OpenGL::glLoadIdentity", XS_SDL__OpenGL_glLoadIdentity, file);
4625         newXS("SDL::OpenGL::glLoadMatrix", XS_SDL__OpenGL_glLoadMatrix, file);
4626         newXS("SDL::OpenGL::glMultMatrix", XS_SDL__OpenGL_glMultMatrix, file);
4627         newXS("SDL::OpenGL::glTranslate", XS_SDL__OpenGL_glTranslate, file);
4628         newXS("SDL::OpenGL::glRotate", XS_SDL__OpenGL_glRotate, file);
4629         newXS("SDL::OpenGL::glScale", XS_SDL__OpenGL_glScale, file);
4630         newXS("SDL::OpenGL::glFrustum", XS_SDL__OpenGL_glFrustum, file);
4631         newXS("SDL::OpenGL::glOrtho", XS_SDL__OpenGL_glOrtho, file);
4632         newXS("SDL::OpenGL::glViewport", XS_SDL__OpenGL_glViewport, file);
4633         newXS("SDL::OpenGL::glDepthRange", XS_SDL__OpenGL_glDepthRange, file);
4634         newXS("SDL::OpenGL::glPushMatrix", XS_SDL__OpenGL_glPushMatrix, file);
4635         newXS("SDL::OpenGL::glPopMatrix", XS_SDL__OpenGL_glPopMatrix, file);
4636         newXS("SDL::OpenGL::glClipPlane", XS_SDL__OpenGL_glClipPlane, file);
4637         newXS("SDL::OpenGL::glColor", XS_SDL__OpenGL_glColor, file);
4638         newXS("SDL::OpenGL::glIndex", XS_SDL__OpenGL_glIndex, file);
4639         newXS("SDL::OpenGL::glShadeModel", XS_SDL__OpenGL_glShadeModel, file);
4640         newXS("SDL::OpenGL::glLight", XS_SDL__OpenGL_glLight, file);
4641         newXS("SDL::OpenGL::glLightModel", XS_SDL__OpenGL_glLightModel, file);
4642         newXS("SDL::OpenGL::glMaterial", XS_SDL__OpenGL_glMaterial, file);
4643         newXS("SDL::OpenGL::glColorMaterial", XS_SDL__OpenGL_glColorMaterial, file);
4644         newXS("SDL::OpenGL::glBlendFunc", XS_SDL__OpenGL_glBlendFunc, file);
4645         newXS("SDL::OpenGL::glHint", XS_SDL__OpenGL_glHint, file);
4646         newXS("SDL::OpenGL::glFog", XS_SDL__OpenGL_glFog, file);
4647         newXS("SDL::OpenGL::glPolygonOffset", XS_SDL__OpenGL_glPolygonOffset, file);
4648         newXS("SDL::OpenGL::glGenLists", XS_SDL__OpenGL_glGenLists, file);
4649         newXS("SDL::OpenGL::glNewList", XS_SDL__OpenGL_glNewList, file);
4650         newXS("SDL::OpenGL::glEndList", XS_SDL__OpenGL_glEndList, file);
4651         newXS("SDL::OpenGL::glDeleteLists", XS_SDL__OpenGL_glDeleteLists, file);
4652         newXS("SDL::OpenGL::glCallList", XS_SDL__OpenGL_glCallList, file);
4653         newXS("SDL::OpenGL::glIsList", XS_SDL__OpenGL_glIsList, file);
4654         newXS("SDL::OpenGL::glListBase", XS_SDL__OpenGL_glListBase, file);
4655         newXS("SDL::OpenGL::glCallLists", XS_SDL__OpenGL_glCallLists, file);
4656         newXS("SDL::OpenGL::glCallListsString", XS_SDL__OpenGL_glCallListsString, file);
4657         newXS("SDL::OpenGL::glRasterPos", XS_SDL__OpenGL_glRasterPos, file);
4658         newXS("SDL::OpenGL::glBitmap", XS_SDL__OpenGL_glBitmap, file);
4659         newXS("SDL::OpenGL::glDrawPixels", XS_SDL__OpenGL_glDrawPixels, file);
4660         newXS("SDL::OpenGL::glReadPixels", XS_SDL__OpenGL_glReadPixels, file);
4661         newXS("SDL::OpenGL::glReadPixel", XS_SDL__OpenGL_glReadPixel, file);
4662         newXS("SDL::OpenGL::glCopyPixels", XS_SDL__OpenGL_glCopyPixels, file);
4663         newXS("SDL::OpenGL::glPixelStore", XS_SDL__OpenGL_glPixelStore, file);
4664         newXS("SDL::OpenGL::glPixelTransfer", XS_SDL__OpenGL_glPixelTransfer, file);
4665         newXS("SDL::OpenGL::glPixelMap", XS_SDL__OpenGL_glPixelMap, file);
4666         newXS("SDL::OpenGL::glPixelZoom", XS_SDL__OpenGL_glPixelZoom, file);
4667 #if XSubPPtmpAAAB
4668         newXS("SDL::OpenGL::glColorTable", XS_SDL__OpenGL_glColorTable, file);
4669         newXS("SDL::OpenGL::glColorTableParameter", XS_SDL__OpenGL_glColorTableParameter, file);
4670         newXS("SDL::OpenGL::glCopyColorTable", XS_SDL__OpenGL_glCopyColorTable, file);
4671         newXS("SDL::OpenGL::glColorSubTable", XS_SDL__OpenGL_glColorSubTable, file);
4672         newXS("SDL::OpenGL::glCopyColorSubTable", XS_SDL__OpenGL_glCopyColorSubTable, file);
4673         newXS("SDL::OpenGL::glConvolutionFilter2D", XS_SDL__OpenGL_glConvolutionFilter2D, file);
4674         newXS("SDL::OpenGL::glCopyConvolutionFilter2D", XS_SDL__OpenGL_glCopyConvolutionFilter2D, file);
4675         newXS("SDL::OpenGL::glSeparableFilter2D", XS_SDL__OpenGL_glSeparableFilter2D, file);
4676         newXS("SDL::OpenGL::glConvolutionFilter1D", XS_SDL__OpenGL_glConvolutionFilter1D, file);
4677         newXS("SDL::OpenGL::glCopyConvolutionFilter1D", XS_SDL__OpenGL_glCopyConvolutionFilter1D, file);
4678         newXS("SDL::OpenGL::glConvolutionParameter", XS_SDL__OpenGL_glConvolutionParameter, file);
4679         newXS("SDL::OpenGL::glHistogram", XS_SDL__OpenGL_glHistogram, file);
4680         newXS("SDL::OpenGL::glGetHistogram", XS_SDL__OpenGL_glGetHistogram, file);
4681         newXS("SDL::OpenGL::glResetHistogram", XS_SDL__OpenGL_glResetHistogram, file);
4682         newXS("SDL::OpenGL::glMinmax", XS_SDL__OpenGL_glMinmax, file);
4683         newXS("SDL::OpenGL::glGetMinmax", XS_SDL__OpenGL_glGetMinmax, file);
4684         newXS("SDL::OpenGL::glResetMinmax", XS_SDL__OpenGL_glResetMinmax, file);
4685         newXS("SDL::OpenGL::glBlendEquation", XS_SDL__OpenGL_glBlendEquation, file);
4686 #endif
4687         newXS("SDL::OpenGL::glTexImage2D", XS_SDL__OpenGL_glTexImage2D, file);
4688         newXS("SDL::OpenGL::glCopyTexImage2D", XS_SDL__OpenGL_glCopyTexImage2D, file);
4689         newXS("SDL::OpenGL::glTexSubImage2D", XS_SDL__OpenGL_glTexSubImage2D, file);
4690         newXS("SDL::OpenGL::glCopyTexSubImage2D", XS_SDL__OpenGL_glCopyTexSubImage2D, file);
4691         newXS("SDL::OpenGL::glTexImage1D", XS_SDL__OpenGL_glTexImage1D, file);
4692         newXS("SDL::OpenGL::glTexSubImage1D", XS_SDL__OpenGL_glTexSubImage1D, file);
4693         newXS("SDL::OpenGL::glCopyTexImage1D", XS_SDL__OpenGL_glCopyTexImage1D, file);
4694         newXS("SDL::OpenGL::glCopyTexSubImage1D", XS_SDL__OpenGL_glCopyTexSubImage1D, file);
4695 #if XSubPPtmpAAAC
4696         newXS("SDL::OpenGL::glTexImage3D", XS_SDL__OpenGL_glTexImage3D, file);
4697         newXS("SDL::OpenGL::glTexSubImage3D", XS_SDL__OpenGL_glTexSubImage3D, file);
4698         newXS("SDL::OpenGL::glCopyTexSubImage3D", XS_SDL__OpenGL_glCopyTexSubImage3D, file);
4699 #endif
4700         newXS("SDL::OpenGL::glGenTextures", XS_SDL__OpenGL_glGenTextures, file);
4701         newXS("SDL::OpenGL::glIsTexture", XS_SDL__OpenGL_glIsTexture, file);
4702         newXS("SDL::OpenGL::glBindTexture", XS_SDL__OpenGL_glBindTexture, file);
4703         newXS("SDL::OpenGL::glDeleteTextures", XS_SDL__OpenGL_glDeleteTextures, file);
4704         newXS("SDL::OpenGL::glAreTexturesResident", XS_SDL__OpenGL_glAreTexturesResident, file);
4705         newXS("SDL::OpenGL::glPrioritizeTextures", XS_SDL__OpenGL_glPrioritizeTextures, file);
4706         newXS("SDL::OpenGL::glTexEnv", XS_SDL__OpenGL_glTexEnv, file);
4707         newXS("SDL::OpenGL::glTexCoord", XS_SDL__OpenGL_glTexCoord, file);
4708         newXS("SDL::OpenGL::glTexParameter", XS_SDL__OpenGL_glTexParameter, file);
4709         newXS("SDL::OpenGL::glTexGen", XS_SDL__OpenGL_glTexGen, file);
4710 #if XSubPPtmpAAAD
4711         newXS("SDL::OpenGL::glActiveTextureARB", XS_SDL__OpenGL_glActiveTextureARB, file);
4712         newXS("SDL::OpenGL::glMultiTexCoord", XS_SDL__OpenGL_glMultiTexCoord, file);
4713 #endif
4714         newXS("SDL::OpenGL::glDrawBuffer", XS_SDL__OpenGL_glDrawBuffer, file);
4715         newXS("SDL::OpenGL::glReadBuffer", XS_SDL__OpenGL_glReadBuffer, file);
4716         newXS("SDL::OpenGL::glIndexMask", XS_SDL__OpenGL_glIndexMask, file);
4717         newXS("SDL::OpenGL::glColorMask", XS_SDL__OpenGL_glColorMask, file);
4718         newXS("SDL::OpenGL::glDepthMask", XS_SDL__OpenGL_glDepthMask, file);
4719         newXS("SDL::OpenGL::glStencilMask", XS_SDL__OpenGL_glStencilMask, file);
4720         newXS("SDL::OpenGL::glScissor", XS_SDL__OpenGL_glScissor, file);
4721         newXS("SDL::OpenGL::glAlphaFunc", XS_SDL__OpenGL_glAlphaFunc, file);
4722         newXS("SDL::OpenGL::glStencilFunc", XS_SDL__OpenGL_glStencilFunc, file);
4723         newXS("SDL::OpenGL::glStencilOp", XS_SDL__OpenGL_glStencilOp, file);
4724         newXS("SDL::OpenGL::glDepthFunc", XS_SDL__OpenGL_glDepthFunc, file);
4725         newXS("SDL::OpenGL::glLogicOp", XS_SDL__OpenGL_glLogicOp, file);
4726         newXS("SDL::OpenGL::glAccum", XS_SDL__OpenGL_glAccum, file);
4727         newXS("SDL::OpenGL::glMap1", XS_SDL__OpenGL_glMap1, file);
4728         newXS("SDL::OpenGL::glEvalCoord1", XS_SDL__OpenGL_glEvalCoord1, file);
4729         newXS("SDL::OpenGL::glMapGrid1", XS_SDL__OpenGL_glMapGrid1, file);
4730         newXS("SDL::OpenGL::glEvalMesh1", XS_SDL__OpenGL_glEvalMesh1, file);
4731         newXS("SDL::OpenGL::glMap2", XS_SDL__OpenGL_glMap2, file);
4732         newXS("SDL::OpenGL::glEvalCoord2", XS_SDL__OpenGL_glEvalCoord2, file);
4733         newXS("SDL::OpenGL::glMapGrid2", XS_SDL__OpenGL_glMapGrid2, file);
4734         newXS("SDL::OpenGL::glEvalMesh2", XS_SDL__OpenGL_glEvalMesh2, file);
4735         newXS("SDL::OpenGL::glGetError", XS_SDL__OpenGL_glGetError, file);
4736         newXS("SDL::OpenGL::glRenderMode", XS_SDL__OpenGL_glRenderMode, file);
4737         newXS("SDL::OpenGL::glInitNames", XS_SDL__OpenGL_glInitNames, file);
4738         newXS("SDL::OpenGL::glPushName", XS_SDL__OpenGL_glPushName, file);
4739         newXS("SDL::OpenGL::glPopName", XS_SDL__OpenGL_glPopName, file);
4740         newXS("SDL::OpenGL::glLoadName", XS_SDL__OpenGL_glLoadName, file);
4741         newXS("SDL::OpenGL::glFeedbackBuffer", XS_SDL__OpenGL_glFeedbackBuffer, file);
4742         newXS("SDL::OpenGL::glPassThrough", XS_SDL__OpenGL_glPassThrough, file);
4743 #endif
4744 #if XSubPPtmpAAAE
4745         newXS("SDL::OpenGL::gluLookAt", XS_SDL__OpenGL_gluLookAt, file);
4746         newXS("SDL::OpenGL::gluPerspective", XS_SDL__OpenGL_gluPerspective, file);
4747         newXS("SDL::OpenGL::gluPickMatrix", XS_SDL__OpenGL_gluPickMatrix, file);
4748         newXS("SDL::OpenGL::gluOrtho2D", XS_SDL__OpenGL_gluOrtho2D, file);
4749         newXS("SDL::OpenGL::gluScaleImage", XS_SDL__OpenGL_gluScaleImage, file);
4750         newXS("SDL::OpenGL::gluBuild1DMipmaps", XS_SDL__OpenGL_gluBuild1DMipmaps, file);
4751         newXS("SDL::OpenGL::gluBuild2DMipmaps", XS_SDL__OpenGL_gluBuild2DMipmaps, file);
4752 #if XSubPPtmpAAAF
4753         newXS("SDL::OpenGL::gluBuild3DMipmaps", XS_SDL__OpenGL_gluBuild3DMipmaps, file);
4754 #endif
4755 #if XSubPPtmpAAAG
4756         newXS("SDL::OpenGL::gluBuild3DMipmaps", XS_SDL__OpenGL_gluBuild3DMipmaps, file);
4757 #endif
4758 #if XSubPPtmpAAAH
4759         newXS("SDL::OpenGL::gluBuild1DMipmapLevels", XS_SDL__OpenGL_gluBuild1DMipmapLevels, file);
4760 #endif
4761 #if XSubPPtmpAAAI
4762         newXS("SDL::OpenGL::gluBuild1DMipmapLevels", XS_SDL__OpenGL_gluBuild1DMipmapLevels, file);
4763 #endif
4764 #if XSubPPtmpAAAJ
4765         newXS("SDL::OpenGL::gluBuild2DMipmapLevels", XS_SDL__OpenGL_gluBuild2DMipmapLevels, file);
4766 #endif
4767 #if XSubPPtmpAAAK
4768         newXS("SDL::OpenGL::gluBuild2DMipmapLevels", XS_SDL__OpenGL_gluBuild2DMipmapLevels, file);
4769 #endif
4770 #if XSubPPtmpAAAL
4771         newXS("SDL::OpenGL::gluBuild3DMipmapLevels", XS_SDL__OpenGL_gluBuild3DMipmapLevels, file);
4772 #endif
4773 #if XSubPPtmpAAAM
4774         newXS("SDL::OpenGL::gluBuild3DMipmapLevels", XS_SDL__OpenGL_gluBuild3DMipmapLevels, file);
4775 #endif
4776         newXS("SDL::OpenGL::gluErrorString", XS_SDL__OpenGL_gluErrorString, file);
4777         newXS("SDL::OpenGL::gluNewNurbsRenderer", XS_SDL__OpenGL_gluNewNurbsRenderer, file);
4778         newXS("SDL::OpenGL::gluDeleteNurbsRenderer", XS_SDL__OpenGL_gluDeleteNurbsRenderer, file);
4779         newXS("SDL::OpenGL::gluNurbsProperty", XS_SDL__OpenGL_gluNurbsProperty, file);
4780         newXS("SDL::OpenGL::gluLoadSamplingMatrices", XS_SDL__OpenGL_gluLoadSamplingMatrices, file);
4781         newXS("SDL::OpenGL::gluGetNurbsProperty", XS_SDL__OpenGL_gluGetNurbsProperty, file);
4782         newXS("SDL::OpenGL::gluNurbsCallback", XS_SDL__OpenGL_gluNurbsCallback, file);
4783         newXS("SDL::OpenGL::gluNurbsCallbackData", XS_SDL__OpenGL_gluNurbsCallbackData, file);
4784         newXS("SDL::OpenGL::gluBeginSurface", XS_SDL__OpenGL_gluBeginSurface, file);
4785         newXS("SDL::OpenGL::gluEndSurface", XS_SDL__OpenGL_gluEndSurface, file);
4786         newXS("SDL::OpenGL::gluNurbsSurface", XS_SDL__OpenGL_gluNurbsSurface, file);
4787         newXS("SDL::OpenGL::gluBeginCurve", XS_SDL__OpenGL_gluBeginCurve, file);
4788         newXS("SDL::OpenGL::gluEndCurve", XS_SDL__OpenGL_gluEndCurve, file);
4789         newXS("SDL::OpenGL::gluNurbsCurve", XS_SDL__OpenGL_gluNurbsCurve, file);
4790         newXS("SDL::OpenGL::gluBeginTrim", XS_SDL__OpenGL_gluBeginTrim, file);
4791         newXS("SDL::OpenGL::gluEndTrim", XS_SDL__OpenGL_gluEndTrim, file);
4792         newXS("SDL::OpenGL::gluPwlCurve", XS_SDL__OpenGL_gluPwlCurve, file);
4793         newXS("SDL::OpenGL::gluUnProject", XS_SDL__OpenGL_gluUnProject, file);
4794 #if XSubPPtmpAAAN
4795         newXS("SDL::OpenGL::gluUnProject4", XS_SDL__OpenGL_gluUnProject4, file);
4796 #endif
4797         newXS("SDL::OpenGL::gluProject", XS_SDL__OpenGL_gluProject, file);
4798 #if XSubPPtmpAAAO
4799         newXS("SDL::OpenGL::gluNewTess", XS_SDL__OpenGL_gluNewTess, file);
4800         newXS("SDL::OpenGL::gluTessCallback", XS_SDL__OpenGL_gluTessCallback, file);
4801         newXS("SDL::OpenGL::gluTessProperty", XS_SDL__OpenGL_gluTessProperty, file);
4802         newXS("SDL::OpenGL::gluGetTessProperty", XS_SDL__OpenGL_gluGetTessProperty, file);
4803         newXS("SDL::OpenGL::gluTessNormal", XS_SDL__OpenGL_gluTessNormal, file);
4804         newXS("SDL::OpenGL::gluTessBeginPolygon", XS_SDL__OpenGL_gluTessBeginPolygon, file);
4805         newXS("SDL::OpenGL::gluTessEndPolygon", XS_SDL__OpenGL_gluTessEndPolygon, file);
4806         newXS("SDL::OpenGL::gluTessBeginContour", XS_SDL__OpenGL_gluTessBeginContour, file);
4807         newXS("SDL::OpenGL::gluTessEndContour", XS_SDL__OpenGL_gluTessEndContour, file);
4808         newXS("SDL::OpenGL::gluDeleteTess", XS_SDL__OpenGL_gluDeleteTess, file);
4809         newXS("SDL::OpenGL::gluTessVertex", XS_SDL__OpenGL_gluTessVertex, file);
4810 #endif
4811 #endif
4812
4813     /* Initialisation Section */
4814
4815 #if XSubPPtmpAAAA
4816 #if XSubPPtmpAAAB
4817 #endif
4818 #if XSubPPtmpAAAC
4819 #endif
4820 #if XSubPPtmpAAAD
4821 #endif
4822 #endif
4823 #if XSubPPtmpAAAE
4824 #if XSubPPtmpAAAF
4825 #endif
4826 #if XSubPPtmpAAAG
4827 #endif
4828 #if XSubPPtmpAAAH
4829 #endif
4830 #if XSubPPtmpAAAI
4831 #endif
4832 #if XSubPPtmpAAAJ
4833 #endif
4834 #if XSubPPtmpAAAK
4835 #endif
4836 #if XSubPPtmpAAAL
4837 #endif
4838 #if XSubPPtmpAAAM
4839 #endif
4840 #if XSubPPtmpAAAN
4841 #endif
4842 #if XSubPPtmpAAAO
4843 #endif
4844 #endif
4845 #line 4846 "OpenGL.c"
4846
4847     /* End of Initialisation Section */
4848
4849     XSRETURN_YES;
4850 }
4851