src/OpenGL.xs

   1 // SDL::OpenGL
   2 //
   3 // Copyright (C) 2002,2003,2004 David J. Goehrig
   4
   5 #include "EXTERN.h"
   6 #include "perl.h"
   7 #include "XSUB.h"
   8
   9 #ifndef aTHX_
  10 #define aTHX_
  11 #endif
  12
  13 #include <SDL.h>
  14
  15 #include <gl.h>
  16 #include <glu.h>
  17
  18 #ifdef USE_THREADS
  19 #define HAVE_TLS_CONTEXT
  20 #endif
  21
  22 #ifndef GL_ALL_CLIENT_ATTRIB_BITS
  23 #define GL_ALL_CLIENT_ATTRIB_BITS 0xFFFFFFF
  24 #endif /* GL_ALL_CLIENT_BITS */
  25
  26 #include "defines.h"
  27
  28 SV* sdl_perl_nurbs_error_hook;
  29 void
  30 sdl_perl_nurbs_error_callback ( GLenum errorCode )
  31 {
  32         ENTER_TLS_CONTEXT
  33         dSP;
  34
  35         ENTER;
  36         SAVETMPS;
  37         PUSHMARK(SP);
  38         XPUSHs(sv_2mortal(newSViv(errorCode)));
  39         PUTBACK;
  40
  41         call_sv(sdl_perl_nurbs_error_hook,G_VOID);
  42
  43         FREETMPS;
  44         LEAVE;
  45         LEAVE_TLS_CONTEXT
  46 }
  47
  48 void
  49 sdl_perl_nurbs_being_callback ( GLenum type, void *cb )
  50 {
  51         SV *cmd;
  52         ENTER_TLS_CONTEXT
  53         dSP;
  54
  55         cmd = (SV*)cb;
  56
  57         ENTER;
  58         SAVETMPS;
  59         PUSHMARK(SP);
  60         XPUSHs(sv_2mortal(newSViv(type)));
  61         PUTBACK;
  62
  63         call_sv(cmd,G_VOID);
  64
  65         FREETMPS;
  66         LEAVE;
  67         LEAVE_TLS_CONTEXT
  68 }
  69
  70 void
  71 sdl_perl_nurbs_multi_callback ( GLfloat *vec, void *cb )
  72 {
  73         SV *cmd;
  74         ENTER_TLS_CONTEXT
  75         dSP;
  76
  77         cmd = (SV*)cb;
  78
  79         ENTER;
  80         SAVETMPS;
  81         PUSHMARK(SP);
  82         XPUSHs(sv_2mortal(newSViv(PTR2IV(vec))));
  83         PUTBACK;
  84
  85         call_sv(cmd,G_VOID);
  86
  87         FREETMPS;
  88         LEAVE;
  89         LEAVE_TLS_CONTEXT
  90 }
  91
  92 void
  93 sdl_perl_nurbs_end_callback ( void *cb )
  94 {
  95         SV *cmd;
  96         ENTER_TLS_CONTEXT
  97
  98         cmd = (SV*)cb;
  99
 100         ENTER;
 101         SAVETMPS;
 102
 103         call_sv(cmd,G_VOID);
 104
 105         FREETMPS;
 106         LEAVE;
 107         LEAVE_TLS_CONTEXT
 108 }
 109
 110 void
 111 sdl_perl_tess_end_callback ( void *cb )
 112 {
 113         SV *cmd;
 114         ENTER_TLS_CONTEXT
 115         dSP;
 116
 117         cmd = (SV*)cb;
 118
 119         ENTER;
 120         SAVETMPS;
 121         PUSHMARK(SP);
 122         XPUSHs(sv_2mortal(newSViv(GLU_TESS_BEGIN)));
 123         PUTBACK;
 124
 125         call_sv(cmd,G_VOID);
 126
 127         FREETMPS;
 128         LEAVE;
 129         LEAVE_TLS_CONTEXT
 130 }
 131
 132 void
 133 sdl_perl_tess_begin_callback ( GLenum type,  void *cb )
 134 {
 135         SV *cmd;
 136         ENTER_TLS_CONTEXT
 137         dSP;
 138
 139         cmd = (SV*)cb;
 140
 141         ENTER;
 142         SAVETMPS;
 143         PUSHMARK(SP);
 144         XPUSHs(sv_2mortal(newSViv(GLU_TESS_BEGIN)));
 145         XPUSHs(sv_2mortal(newSViv(type)));
 146         PUTBACK;
 147
 148         call_sv(cmd,G_VOID);
 149
 150         FREETMPS;
 151         LEAVE;
 152         LEAVE_TLS_CONTEXT
 153 }
 154
 155 void
 156 sdl_perl_tess_error_callback ( GLenum type,  void *cb )
 157 {
 158         SV *cmd;
 159         ENTER_TLS_CONTEXT
 160         dSP;
 161
 162         cmd = (SV*)cb;
 163
 164         ENTER;
 165         SAVETMPS;
 166         PUSHMARK(SP);
 167         XPUSHs(sv_2mortal(newSViv(GLU_TESS_ERROR)));
 168         XPUSHs(sv_2mortal(newSViv(type)));
 169         PUTBACK;
 170
 171         call_sv(cmd,G_VOID);
 172
 173         FREETMPS;
 174         LEAVE;
 175         LEAVE_TLS_CONTEXT
 176 }
 177
 178 void
 179 sdl_perl_tess_edge_flag_callback ( GLenum flag,  void *cb )
 180 {
 181         SV *cmd;
 182         ENTER_TLS_CONTEXT
 183         dSP;
 184
 185         cmd = (SV*)cb;
 186
 187         ENTER;
 188         SAVETMPS;
 189         PUSHMARK(SP);
 190         XPUSHs(sv_2mortal(newSViv(GLU_TESS_EDGE_FLAG)));
 191         XPUSHs(sv_2mortal(newSViv(flag)));
 192         PUTBACK;
 193
 194         call_sv(cmd,G_VOID);
 195
 196         FREETMPS;
 197         LEAVE;
 198         LEAVE_TLS_CONTEXT
 199 }
 200
 201 void
 202 sdl_perl_tess_vertex_callback ( double *vd,  void *cb )
 203 {
 204         SV *cmd;
 205         ENTER_TLS_CONTEXT
 206         dSP;
 207
 208         cmd = (SV*)cb;
 209
 210         ENTER;
 211         SAVETMPS;
 212         PUSHMARK(SP);
 213         XPUSHs(sv_2mortal(newSViv(GLU_TESS_VERTEX)));
 214         XPUSHs(sv_2mortal(newSVnv(vd[0])));
 215         XPUSHs(sv_2mortal(newSVnv(vd[1])));
 216         XPUSHs(sv_2mortal(newSVnv(vd[2])));
 217         XPUSHs(sv_2mortal(newSVnv(vd[3])));
 218         XPUSHs(sv_2mortal(newSVnv(vd[4])));
 219         XPUSHs(sv_2mortal(newSVnv(vd[5])));
 220         PUTBACK;
 221
 222         call_sv(cmd,G_VOID);
 223
 224         FREETMPS;
 225         LEAVE;
 226         LEAVE_TLS_CONTEXT
 227 }
 228
 229 void
 230 sdl_perl_tess_combine_callback ( GLdouble coords[3], double *vd[4], GLfloat weight[4],
 231         GLdouble **out, void *cb )
 232 {
 233         SV *cmd;
 234         double *data;
 235         int width;
 236         ENTER_TLS_CONTEXT
 237         dSP;
 238
 239         cmd = (SV*)cb;
 240
 241         ENTER;
 242         SAVETMPS;
 243         PUSHMARK(SP);
 244         XPUSHs(sv_2mortal(newSViv(GLU_TESS_COMBINE)));
 245         XPUSHs(sv_2mortal(newSVpvn((char*)coords,sizeof(GLdouble)*3)));
 246         XPUSHs(sv_2mortal(newSVpvn((char*)vd,sizeof(GLdouble*)*4)));
 247         XPUSHs(sv_2mortal(newSVpvn((char*)weight,sizeof(GLfloat)*4)));
 248         PUTBACK;
 249
 250         if ( 1 != call_sv(cmd,G_SCALAR) ) {
 251                 Perl_croak(aTHX_ "sdl_perl_tess_combine_callback failed");
 252         }
 253
 254         data = (double*)POPp;
 255         width = (int)POPi;
 256         *out = (double*)malloc(sizeof(double)*width);
 257         memcpy(*out,data,sizeof(double)*width);
 258
 259         FREETMPS;
 260         LEAVE;
 261         LEAVE_TLS_CONTEXT
 262 }
 263
 264 MODULE = SDL::OpenGL            PACKAGE = SDL::OpenGL
 265 PROTOTYPES : DISABLE
 266
 267 #ifdef HAVE_GL
 268
 269 void
 270 glClearColor ( r, g, b, a)
 271         double r
 272         double g
 273         double b
 274         double a
 275         CODE:
 276                 glClearColor((GLfloat)r,(GLfloat)g,(GLfloat)b,(GLfloat)a);
 277
 278 void
 279 glClearIndex ( index )
 280         double index
 281         CODE:
 282                 glClearIndex(index);
 283
 284 void
 285 glClearDepth ( depth )
 286         double depth
 287         CODE:
 288                 glClearDepth(depth);
 289
 290 void
 291 glClearStencil ( s )
 292         int s
 293         CODE:
 294                 glClearStencil(s);
 295
 296 void
 297 glClearAccum ( r, g, b, a )
 298         double r
 299         double g
 300         double b
 301         double a
 302         CODE:
 303                 glClearAccum((GLfloat)r,(GLfloat)g,(GLfloat)b,(GLfloat)a);
 304
 305 void
 306 glClear ( m )
 307         GLbitfield m
 308         CODE:
 309                 glClear(m);
 310
 311 void
 312 glFlush ()
 313         CODE:
 314                 glFlush();
 315
 316 void
 317 glFinish ()
 318         CODE:
 319                 glFinish();
 320
 321 void
 322 glRect ( r )
 323         SDL_Rect* r
 324         CODE:
 325                 glRecti(r->x,r->y,r->x+r->w,r->y+r->h);
 326
 327 void
 328 glVertex ( x, y, ... )
 329         double x
 330         double y
 331         CODE:
 332                 double z,w;
 333                 if ( items == 4 ) {
 334                         w = SvNV(ST(3));
 335                         z = SvNV(ST(2));
 336                         glVertex4d(x,y,z,w);
 337                 } else if ( items == 3 ) {
 338                         z = SvNV(ST(2));
 339                         glVertex3d(x,y,z);
 340                 } else {
 341                         glVertex2d(x,y);
 342                 }
 343
 344 void
 345 glBegin ( mode )
 346         GLenum mode
 347         CODE:
 348                 glBegin(mode);
 349
 350 void
 351 glEnd ()
 352         CODE:
 353                 glEnd();
 354
 355 void
 356 glEnable ( cap )
 357         GLenum cap
 358         CODE:
 359                 glEnable(cap);
 360
 361 void
 362 glDisable ( cap )
 363         GLenum cap
 364         CODE:
 365                 glDisable(cap);
 366
 367 void
 368 glGet ( param )
 369         GLenum param
 370     PPCODE:
 371         switch (param) {
 372         case GL_EDGE_FLAG_ARRAY:
 373         case GL_MAP1_TEXTURE_COORD_1:
 374         case GL_LIGHT_MODEL_TWO_SIDE:
 375         case GL_INDEX_LOGIC_OP:
 376         case GL_PACK_ALIGNMENT:
 377         case GL_CLIP_PLANE4:
 378         case GL_TEXTURE_GEN_S:
 379         case GL_MAP1_VERTEX_3:
 380         case GL_LIGHT6:
 381         case GL_LIGHT0:
 382         case GL_NORMAL_ARRAY:
 383         case GL_EDGE_FLAG:
 384         case GL_INDEX_ARRAY:
 385         case GL_AUTO_NORMAL:
 386         case GL_POLYGON_OFFSET_FILL:
 387         case GL_MAP1_TEXTURE_COORD_4:
 388         case GL_FOG:
 389         case GL_LIGHT2:
 390         case GL_UNPACK_SWAP_BYTES:
 391         case GL_RGBA_MODE:
 392         case GL_POLYGON_OFFSET_POINT:
 393         case GL_POINT_SMOOTH:
 394         case GL_ALPHA_TEST:
 395         case GL_MAP2_TEXTURE_COORD_4:
 396         case GL_COLOR_ARRAY:
 397         case GL_POLYGON_OFFSET_LINE:
 398         case GL_MAP2_NORMAL:
 399         case GL_MAP1_INDEX:
 400         case GL_PACK_LSB_FIRST:
 401         case GL_MAP1_TEXTURE_COORD_2:
 402         case GL_MAP2_VERTEX_3:
 403         case GL_MAP2_TEXTURE_COORD_2:
 404         case GL_CULL_FACE:
 405         case GL_DOUBLEBUFFER:
 406         case GL_UNPACK_LSB_FIRST:
 407         case GL_TEXTURE_COORD_ARRAY:
 408         case GL_LIGHT1:
 409         case GL_TEXTURE_GEN_Q:
 410         case GL_MAP_STENCIL:
 411         case GL_TEXTURE_1D:
 412         case GL_LIGHT4:
 413         case GL_LIGHTING:
 414         case GL_LIGHT7:
 415         case GL_MAP1_NORMAL:
 416         case GL_CLIP_PLANE0:
 417         case GL_TEXTURE_GEN_R:
 418         case GL_PACK_SWAP_BYTES:
 419         case GL_DEPTH_WRITEMASK:
 420         case GL_COLOR_LOGIC_OP:
 421         case GL_CLIP_PLANE5:
 422         case GL_NORMALIZE:
 423         case GL_TEXTURE_2D:
 424         case GL_CLIP_PLANE3:
 425         case GL_COLOR_MATERIAL:
 426         case GL_BLEND:
 427         case GL_CLIP_PLANE2:
 428         case GL_MAP1_VERTEX_4:
 429         case GL_DITHER:
 430         case GL_CLIP_PLANE1:
 431         case GL_MAP2_INDEX:
 432         case GL_POLYGON_SMOOTH:
 433         case GL_STEREO:
 434         case GL_MAP2_COLOR_4:
 435         case GL_LIGHT3:
 436         case GL_VERTEX_ARRAY:
 437         case GL_MAP1_TEXTURE_COORD_3:
 438         case GL_STENCIL_TEST:
 439         case GL_MAP2_TEXTURE_COORD_3:
 440         case GL_TEXTURE_GEN_T:
 441         case GL_LIGHT_MODEL_LOCAL_VIEWER:
 442         case GL_LINE_SMOOTH:
 443         case GL_MAP1_COLOR_4:
 444         case GL_MAP2_TEXTURE_COORD_1:
 445         case GL_CURRENT_RASTER_POSITION_VALID:
 446         case GL_INDEX_MODE:
 447         case GL_SCISSOR_TEST:
 448         case GL_MAP_COLOR:
 449         case GL_POLYGON_STIPPLE:
 450         case GL_LIGHT5:
 451         case GL_DEPTH_TEST:
 452         case GL_LINE_STIPPLE:
 453         case GL_MAP2_VERTEX_4:
 454         {
 455             GLboolean ret[1];
 456             int i;
 457             glGetBooleanv(param, ret);
 458
 459             for (i = 0; i < 1; i++) {
 460                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 461             }
 462             break;
 463         }
 464         case GL_COLOR_WRITEMASK:
 465         {
 466             GLboolean ret[4];
 467             int i;
 468             glGetBooleanv(param, ret);
 469
 470             for (i = 0; i < 4; i++) {
 471                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 472             }
 473             break;
 474         }
 475         case GL_ZOOM_Y:
 476         case GL_ALPHA_TEST_REF:
 477         case GL_POINT_SIZE_GRANULARITY:
 478         case GL_CURRENT_RASTER_DISTANCE:
 479         case GL_ALPHA_SCALE:
 480         case GL_RED_BIAS:
 481         case GL_DEPTH_BIAS:
 482         case GL_FOG_DENSITY:
 483         case GL_GREEN_BIAS:
 484         case GL_DEPTH_CLEAR_VALUE:
 485         case GL_ALPHA_BIAS:
 486         case GL_FOG_END:
 487         case GL_GREEN_SCALE:
 488         case GL_BLUE_BIAS:
 489         case GL_DEPTH_SCALE:
 490         case GL_POINT_SIZE:
 491         case GL_POLYGON_OFFSET_FACTOR:
 492         case GL_ZOOM_X:
 493         case GL_FOG_START:
 494         case GL_POLYGON_OFFSET_UNITS:
 495         case GL_LINE_WIDTH:
 496         case GL_LINE_WIDTH_GRANULARITY:
 497         case GL_BLUE_SCALE:
 498         case GL_RED_SCALE:
 499         {
 500             GLdouble ret[1];
 501             int i;
 502             glGetDoublev(param, ret);
 503
 504             for (i = 0; i < 1; i++) {
 505                 XPUSHs(sv_2mortal(newSVnv(ret[i])));
 506             }
 507             break;
 508         }
 509         case GL_MODELVIEW_MATRIX:
 510         case GL_TEXTURE_MATRIX:
 511         case GL_PROJECTION_MATRIX:
 512         {
 513             GLdouble ret[16];
 514             int i;
 515             glGetDoublev(param, ret);
 516
 517             for (i = 0; i < 16; i++) {
 518                 XPUSHs(sv_2mortal(newSVnv(ret[i])));
 519             }
 520             break;
 521         }
 522         case GL_POINT_SIZE_RANGE:
 523         case GL_LINE_WIDTH_RANGE:
 524         case GL_MAP1_GRID_DOMAIN:
 525         case GL_DEPTH_RANGE:
 526         {
 527             GLdouble ret[2];
 528             int i;
 529             glGetDoublev(param, ret);
 530
 531             for (i = 0; i < 2; i++) {
 532                 XPUSHs(sv_2mortal(newSVnv(ret[i])));
 533             }
 534             break;
 535         }
 536         case GL_CURRENT_NORMAL:
 537         {
 538             GLdouble ret[3];
 539             int i;
 540             glGetDoublev(param, ret);
 541
 542             for (i = 0; i < 3; i++) {
 543                 XPUSHs(sv_2mortal(newSVnv(ret[i])));
 544             }
 545             break;
 546         }
 547         case GL_FOG_COLOR:
 548         case GL_MAP2_GRID_DOMAIN:
 549         case GL_CURRENT_RASTER_POSITION:
 550         case GL_CURRENT_COLOR:
 551         case GL_LIGHT_MODEL_AMBIENT:
 552         case GL_CURRENT_RASTER_TEXTURE_COORDS:
 553         case GL_TEXTURE_ENV_COLOR:
 554         case GL_CURRENT_RASTER_COLOR:
 555         case GL_CURRENT_TEXTURE_COORDS:
 556         case GL_COLOR_CLEAR_VALUE:
 557         case GL_ACCUM_CLEAR_VALUE:
 558         {
 559             GLdouble ret[4];
 560             int i;
 561             glGetDoublev(param, ret);
 562
 563             for (i = 0; i < 4; i++) {
 564                 XPUSHs(sv_2mortal(newSVnv(ret[i])));
 565             }
 566             break;
 567         }
 568         case GL_CULL_FACE_MODE:
 569         case GL_PIXEL_MAP_I_TO_A_SIZE:
 570         case GL_PIXEL_MAP_A_TO_A_SIZE:
 571         case GL_BLUE_BITS:
 572         case GL_EDGE_FLAG_ARRAY_STRIDE:
 573         case GL_RENDER_MODE:
 574         case GL_FOG_MODE:
 575         case GL_DEPTH_FUNC:
 576         case GL_READ_BUFFER:
 577         case GL_POINT_SMOOTH_HINT:
 578         case GL_PACK_SKIP_PIXELS:
 579         case GL_STENCIL_REF:
 580         case GL_STENCIL_CLEAR_VALUE:
 581         case GL_AUX_BUFFERS:
 582         case GL_COLOR_MATERIAL_PARAMETER:
 583         case GL_ACCUM_BLUE_BITS:
 584         case GL_INDEX_SHIFT:
 585         case GL_VERTEX_ARRAY_STRIDE:
 586         case GL_STENCIL_PASS_DEPTH_PASS:
 587         case GL_CLIENT_ATTRIB_STACK_DEPTH:
 588         case GL_DRAW_BUFFER:
 589         case GL_LINE_STIPPLE_REPEAT:
 590         case GL_BLEND_SRC:
 591         case GL_PIXEL_MAP_B_TO_B_SIZE:
 592         case GL_MAX_PIXEL_MAP_TABLE:
 593         case GL_MAX_TEXTURE_SIZE:
 594         case GL_PIXEL_MAP_S_TO_S_SIZE:
 595         case GL_LOGIC_OP_MODE:
 596         case GL_DEPTH_BITS:
 597         case GL_GREEN_BITS:
 598         case GL_LINE_SMOOTH_HINT:
 599         case GL_ALPHA_TEST_FUNC:
 600         case GL_MAX_LIGHTS:
 601         case GL_FOG_HINT:
 602         case GL_MAX_NAME_STACK_DEPTH:
 603         case GL_INDEX_ARRAY_TYPE:
 604         case GL_TEXTURE_COORD_ARRAY_TYPE:
 605         case GL_COLOR_ARRAY_TYPE:
 606         case GL_MAX_LIST_NESTING:
 607         case GL_STENCIL_WRITEMASK:
 608         case GL_LIST_BASE:
 609         case GL_ACCUM_ALPHA_BITS:
 610         case GL_INDEX_ARRAY_STRIDE:
 611         case GL_PIXEL_MAP_I_TO_B_SIZE:
 612         case GL_INDEX_BITS:
 613         case GL_STENCIL_FAIL:
 614         case GL_UNPACK_ALIGNMENT:
 615         case GL_STENCIL_PASS_DEPTH_FAIL:
 616         case GL_ATTRIB_STACK_DEPTH:
 617         case GL_PACK_SKIP_ROWS:
 618         case GL_TEXTURE_STACK_DEPTH:
 619         case GL_MATRIX_MODE:
 620         case GL_COLOR_ARRAY_STRIDE:
 621         case GL_LIST_MODE:
 622         case GL_UNPACK_SKIP_PIXELS:
 623         case GL_PIXEL_MAP_G_TO_G_SIZE:
 624         case GL_VERTEX_ARRAY_TYPE:
 625         case GL_RED_BITS:
 626         case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
 627         case GL_INDEX_CLEAR_VALUE:
 628         case GL_PIXEL_MAP_I_TO_G_SIZE:
 629         case GL_ALPHA_BITS:
 630         case GL_PIXEL_MAP_I_TO_R_SIZE:
 631         case GL_COLOR_ARRAY_SIZE:
 632         case GL_TEXTURE_COORD_ARRAY_SIZE:
 633         case GL_MAP1_GRID_SEGMENTS:
 634         case GL_VERTEX_ARRAY_SIZE:
 635         case GL_PIXEL_MAP_R_TO_R_SIZE:
 636         case GL_TEXTURE_COORD_ARRAY_STRIDE:
 637         case GL_MODELVIEW_STACK_DEPTH:
 638         case GL_MAX_TEXTURE_STACK_DEPTH:
 639         case GL_PIXEL_MAP_I_TO_I_SIZE:
 640         case GL_FOG_INDEX:
 641         case GL_INDEX_WRITEMASK:
 642         case GL_PACK_ROW_LENGTH:
 643         case GL_CURRENT_INDEX:
 644         case GL_STENCIL_VALUE_MASK:
 645         case GL_UNPACK_SKIP_ROWS:
 646         case GL_MAX_PROJECTION_STACK_DEPTH:
 647         case GL_LIST_INDEX:
 648         case GL_STENCIL_FUNC:
 649         case GL_INDEX_OFFSET:
 650         case GL_UNPACK_ROW_LENGTH:
 651         case GL_COLOR_MATERIAL_FACE:
 652         case GL_NORMAL_ARRAY_TYPE:
 653         case GL_STENCIL_BITS:
 654         case GL_PROJECTION_STACK_DEPTH:
 655         case GL_CURRENT_RASTER_INDEX:
 656         case GL_SHADE_MODEL:
 657         case GL_TEXTURE_ENV_MODE:
 658         case GL_NORMAL_ARRAY_STRIDE:
 659         case GL_PERSPECTIVE_CORRECTION_HINT:
 660         case GL_MAX_CLIP_PLANES:
 661         case GL_MAX_MODELVIEW_STACK_DEPTH:
 662         case GL_SUBPIXEL_BITS:
 663         case GL_ACCUM_RED_BITS:
 664         case GL_BLEND_DST:
 665         case GL_FRONT_FACE:
 666         case GL_MAX_EVAL_ORDER:
 667         case GL_LINE_STIPPLE_PATTERN:
 668         case GL_NAME_STACK_DEPTH:
 669         case GL_MAX_ATTRIB_STACK_DEPTH:
 670         case GL_POLYGON_SMOOTH_HINT:
 671         case GL_ACCUM_GREEN_BITS:
 672         {
 673             GLint ret[1];
 674             int i;
 675             glGetIntegerv(param, ret);
 676
 677             for (i = 0; i < 1; i++) {
 678                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 679             }
 680             break;
 681         }
 682         case GL_POLYGON_MODE:
 683         case GL_MAX_VIEWPORT_DIMS:
 684         case GL_MAP2_GRID_SEGMENTS:
 685         {
 686             GLint ret[2];
 687             int i;
 688             glGetIntegerv(param, ret);
 689
 690             for (i = 0; i < 2; i++) {
 691                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 692             }
 693             break;
 694         }
 695         case GL_SCISSOR_BOX:
 696         case GL_VIEWPORT:
 697         {
 698             GLint ret[4];
 699             int i;
 700             glGetIntegerv(param, ret);
 701
 702             for (i = 0; i < 4; i++) {
 703                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 704             }
 705             break;
 706         }
 707         default:
 708             croak("Unknown glGet parameter!");
 709         }
 710
 711 const char * glGetString ( name )
 712         GLenum name
 713         CODE:
 714                 RETVAL = (const char *)glGetString (name);
 715         OUTPUT:
 716                 RETVAL
 717
 718 Uint32
 719 glIsEnabled ( cap )
 720         Uint32 cap
 721         CODE:
 722                 RETVAL = glIsEnabled(cap);
 723         OUTPUT:
 724                 RETVAL
 725
 726 void
 727 glPointSize ( size )
 728         double size
 729         CODE:
 730                 glPointSize((GLfloat)size);
 731
 732 void
 733 glLineWidth ( size )
 734         double size
 735         CODE:
 736                 glLineWidth((GLfloat)size);
 737
 738 void
 739 glLineStipple ( factor, pattern )
 740         Sint32 factor
 741         Uint16 pattern
 742         CODE:
 743                 glLineStipple(factor,pattern);
 744
 745 void
 746 glPolygonMode ( face, mode )
 747         GLenum face
 748         GLenum mode
 749         CODE:
 750                 glPolygonMode(face,mode);
 751
 752 void
 753 glFrontFace ( mode )
 754         GLenum mode
 755         CODE:
 756                 glFrontFace(mode);
 757
 758 void
 759 glCullFace ( mode )
 760         GLenum mode
 761         CODE:
 762                 glCullFace(mode);
 763
 764 void
 765 glPolygonStipple ( mask )
 766         char *mask
 767         CODE:
 768                 glPolygonStipple(mask);
 769
 770 void
 771 glEdgeFlag ( flag )
 772         GLenum flag
 773         CODE:
 774                 glEdgeFlag(flag);
 775
 776 void
 777 glNormal ( x, y, z )
 778         double x
 779         double y
 780         double z
 781         CODE:
 782                 glNormal3d(x,y,z);
 783
 784 void
 785 glEnableClientState ( array )
 786         GLenum array
 787         CODE:
 788                 glEnableClientState(array);
 789
 790 void
 791 glDisableClientState ( array )
 792         GLenum array
 793         CODE:
 794                 glDisableClientState(array);
 795
 796 void
 797 glVertexPointer ( size, type, stride, pointer)
 798         int size
 799         GLenum type
 800         Uint32 stride
 801         char *pointer
 802         CODE:
 803                 glVertexPointer(size,type,stride,pointer);
 804
 805 void
 806 glColorPointer ( size, type, stride, pointer )
 807         Sint32 size
 808         GLenum type
 809         Uint32 stride
 810         char *pointer
 811         CODE:
 812                 glColorPointer(size,type,stride,pointer);
 813
 814 void
 815 glNormalPointer ( type, stride, pointer )
 816         GLenum type
 817         Uint32 stride
 818         char *pointer
 819         CODE:
 820                 glNormalPointer(type,stride,pointer);
 821
 822 void
 823 glTexCoordPointer ( size, type, stride, pointer )
 824         Sint32 size
 825         GLenum type
 826         Uint32 stride
 827         char *pointer
 828         CODE:
 829                 glTexCoordPointer(size,type,stride,pointer);
 830
 831 void
 832 glEdgeFlagPointer ( stride, pointer )
 833         Uint32 stride
 834         char *pointer
 835         CODE:
 836                 glEdgeFlagPointer(stride,pointer);
 837
 838 void
 839 glArrayElement ( ith )
 840         Uint32 ith
 841         CODE:
 842                 glArrayElement(ith);
 843
 844 void
 845 glDrawElements ( mode, count, type, indices )
 846         GLenum mode
 847         Uint32 count
 848         GLenum type
 849         char *indices
 850         CODE:
 851                 glDrawElements( mode, count, type, indices);
 852
 853 void
 854 glDrawRangeElements ( mode, start, end, count, type, indices )
 855         GLenum mode
 856         Uint32 start
 857         Uint32 end
 858         Uint32 count
 859         GLenum type
 860         char *indices
 861         CODE:
 862                 glDrawRangeElements(mode,start,end,count,type,indices);
 863
 864 void
 865 glDrawArrays ( mode, first, count )
 866         GLenum mode
 867         Uint32 first
 868         Uint32 count
 869         CODE:
 870                 glDrawArrays(mode,first,count);
 871
 872 void
 873 glInterleavedArrays ( format, stride, pointer )
 874         GLenum format
 875         Uint32 stride
 876         char *pointer
 877         CODE:
 878                 glInterleavedArrays(format,stride,pointer);
 879
 880 void
 881 glPushAttrib ( mask )
 882         GLbitfield mask
 883         CODE:
 884                 glPushAttrib(mask);
 885
 886 void
 887 glPopAttrib ()
 888         CODE:
 889                 glPopAttrib();
 890
 891 void
 892 glPushClientAttrib ( mask )
 893         GLbitfield mask
 894         CODE:
 895                 glPushClientAttrib(mask);
 896
 897 void
 898 glPopClientAttrib ()
 899         CODE:
 900                 glPopClientAttrib();
 901
 902 void
 903 glMatrixMode ( mode )
 904         GLenum mode
 905         CODE:
 906                 glMatrixMode(mode);
 907
 908 void
 909 glLoadIdentity ()
 910         CODE:
 911                 glLoadIdentity();
 912
 913 void
 914 glLoadMatrix (  ... )
 915         CODE:
 916                 int i;
 917                 double mat[16];
 918                 for ( i = 0; i < 16; i++ ) {
 919                         mat[i] = (i < items  && SvNOK(ST(i)) ? SvNV(ST(i)) : 0.0 );
 920                 }
 921                 glLoadMatrixd(mat);
 922
 923 void
 924 glMultMatrix ( ... )
 925         CODE:
 926                 int i;
 927                 double mat[16];
 928                 for ( i = 0; i < 16; i++ ) {
 929                         mat[i] = (i < items  && SvNOK(ST(i)) ? SvNV(ST(i)) : 0.0 );
 930                 }
 931                 glMultMatrixd(mat);
 932
 933 void
 934 glTranslate ( x, y, z )
 935         double x
 936         double y
 937         double z
 938         CODE:
 939                 glTranslated(x,y,z);
 940
 941 void
 942 glRotate ( angle, x, y, z )
 943         double angle
 944         double x
 945         double y
 946         double z
 947         CODE:
 948                 glRotated(angle,x,y,z);
 949
 950 void
 951 glScale ( x, y, z )
 952         double x
 953         double y
 954         double z
 955         CODE:
 956                 glScaled(x,y,z);
 957
 958 void
 959 glFrustum ( left, right, bottom, top, n, f )
 960         double left
 961         double right
 962         double bottom
 963         double top
 964         double n
 965         double f
 966         CODE:
 967                 glFrustum(left,right,bottom,top,n,f);
 968
 969 void
 970 glOrtho ( left, right, bottom, top, n, f )
 971         double left
 972         double right
 973         double bottom
 974         double top
 975         double n
 976         double f
 977         CODE:
 978                 glOrtho(left,right,bottom,top,n,f);
 979
 980 void
 981 glViewport ( x, y, width, height )
 982         Sint32 x
 983         Sint32 y
 984         Uint32 width
 985         Uint32 height
 986         CODE:
 987                 glViewport(x,y,width,height);
 988
 989 void
 990 glDepthRange ( n, f )
 991         double n
 992         double f
 993         CODE:
 994                 glDepthRange(n,f);
 995
 996 void
 997 glPushMatrix ()
 998         CODE:
 999                 glPushMatrix();
1000
1001 void
1002 glPopMatrix ()
1003         CODE:
1004                 glPopMatrix();
1005
1006 void
1007 glClipPlane ( plane, ... )
1008         GLenum plane
1009         CODE:
1010                 double v[4];
1011                 int i;
1012                 for (i = 0; i < 4; i++ ) {
1013                         v[i] = (i+1 < items && SvNOK(ST(i+1))) ? SvNV(ST(i+1)) : 0.0;
1014                 }
1015                 glClipPlane(plane,v);
1016
1017 void
1018 glColor ( r, g, b, ... )
1019         double r
1020         double g
1021         double b
1022         CODE:
1023                 if ( items == 4 ) {
1024                         double a;
1025                         a = SvNV(ST(3));
1026                         glColor4d(r,g,b,a);
1027                 } else {
1028                         glColor3d(r,g,b);
1029                 }
1030
1031 void
1032 glIndex ( c )
1033         Uint32 c
1034         CODE:
1035                 glIndexi(c);
1036
1037 void
1038 glShadeModel ( mode )
1039         GLenum mode
1040         CODE:
1041                 glShadeModel(mode);
1042
1043 void
1044 glLight ( light, name, ... )
1045         GLenum light
1046         GLenum name
1047         CODE:
1048                 int i;
1049                 if ( items == 6 ) {
1050                         float v[4];
1051                         for ( i = 0; i < 4; i++ ) {
1052                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1053                         }
1054                         glLightfv(light,name,v);
1055                 } else if ( items == 5 ) {
1056                         float v[3];
1057                         for ( i = 0; i < 3; i++ ) {
1058                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1059                         }
1060                         glLightfv(light,name,v);
1061                 } else if ( items == 3 ) {
1062                         float v;
1063                         v = SvNV(ST(2));
1064                         glLightf(light,name,v);
1065                 } else {
1066                         Perl_croak(aTHX_ "SDL::OpenGL::Light invalid arguments");
1067                 }
1068
1069 void
1070 glLightModel ( pname, ... )
1071         GLenum pname
1072         CODE:
1073                 GLfloat vec[4];
1074                 if ( pname == GL_LIGHT_MODEL_LOCAL_VIEWER ||
1075                         pname == GL_LIGHT_MODEL_TWO_SIDE ||
1076                         pname == GL_LIGHT_MODEL_COLOR_CONTROL ) {
1077                         glLightModelf(pname,SvNV(ST(1)));
1078                 } else if ( pname == GL_LIGHT_MODEL_AMBIENT) {
1079                         vec[0] = SvNV(ST(1));
1080                         vec[1] = SvNV(ST(2));
1081                         vec[2] = SvNV(ST(3));
1082                         vec[3] = SvNV(ST(4));
1083                         glLightModelfv(pname,vec);
1084                 } else {
1085                         Perl_croak(aTHX_ "SDL::OpenGL::glLightModel unknown model %d",pname);
1086                 }
1087
1088 void
1089 glMaterial ( face, name, ... )
1090         GLenum face
1091         GLenum name
1092         CODE:
1093                 int i;
1094                 if ( items == 6 ) {
1095                         float v[4];
1096                         for ( i = 0; i < 4; i++ ) {
1097                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1098                         }
1099                         glMaterialfv(face,name,v);
1100                 } else if ( items == 5 ) {
1101                         float v[3];
1102                         for ( i = 0; i < 4; i++ ) {
1103                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1104                         }
1105                         glMaterialfv(face,name,v);
1106                 } else if ( items == 3 ) {
1107                         float v;
1108                         v = SvNV(ST(2));
1109                         glMaterialf(face,name,v);
1110                 } else {
1111                         Perl_croak(aTHX_ "SDL::OpenGL::Material invalid arguments");
1112                 }
1113
1114 void
1115 glColorMaterial ( face, mode )
1116         GLenum face
1117         GLenum mode
1118         CODE:
1119                 glColorMaterial(face,mode);
1120
1121 void
1122 glBlendFunc ( sfactor, dfactor )
1123         GLenum sfactor
1124         GLenum dfactor
1125         CODE:
1126                 glBlendFunc(sfactor,dfactor);
1127
1128
1129 void
1130 glHint ( target, hint )
1131         GLenum target
1132         GLenum hint
1133         CODE:
1134                 glHint(target,hint);
1135
1136 void
1137 glFog ( name, ... )
1138         GLenum name
1139         CODE:
1140                 if ( items == 5 )  {
1141                         float v[4];
1142                         v[0] = SvNV(ST(1));
1143                         v[1] = SvNV(ST(2));
1144                         v[2] = SvNV(ST(3));
1145                         v[3] = SvNV(ST(4));
1146                         glFogfv(name,v);
1147                 } else if ( items == 2 ) {
1148                         float v;
1149                         v = SvNV(ST(1));
1150                         glFogf(name,v);
1151                 } else {
1152                         Perl_croak(aTHX_ "SDL::OpenGL::Material invalid arguments");
1153                 }
1154
1155 void
1156 glPolygonOffset ( factor, units )
1157         double factor
1158         double units
1159         CODE:
1160                 glPolygonOffset(factor,units);
1161
1162 Uint32
1163 glGenLists ( range )
1164         Uint32 range
1165         CODE:
1166                 RETVAL = glGenLists(range);
1167         OUTPUT:
1168                 RETVAL
1169
1170 void
1171 glNewList ( list, mode )
1172         Uint32 list
1173         GLenum mode
1174         CODE:
1175                 glNewList(list,mode);
1176
1177 void
1178 glEndList ()
1179         CODE:
1180                 glEndList();
1181
1182 void
1183 glDeleteLists ( base, count )
1184         Uint32 base
1185         Uint32 count
1186         CODE:
1187                 glDeleteLists(base, count);
1188
1189 void
1190 glCallList ( list )
1191         Uint32 list
1192         CODE:
1193                 glCallList(list);
1194
1195 Uint32
1196 glIsList ( list )
1197         Uint32 list
1198         CODE:
1199                 RETVAL = glIsList(list);
1200         OUTPUT:
1201                 RETVAL
1202
1203 void
1204 glListBase ( base )
1205         Uint32 base
1206         CODE:
1207                 glListBase(base);
1208
1209 void
1210 glCallLists ( ... )
1211         CODE:
1212                 int *i, j;
1213                 if ( items > 0 ) {
1214                         i = (int*)safemalloc(sizeof(int)* (items));
1215                         for ( j = 0; j < items; j++ ) {
1216                                 i[j] = SvIV(ST(j));
1217                         }
1218                 } else {
1219                         Perl_croak(aTHX_ "usage: SDL::OpenGL::CallLists(type,...)");
1220                 }
1221                 glCallLists(items, GL_INT, i);
1222                 safefree(i);
1223
1224 void
1225 glCallListsString ( string )
1226         SV* string
1227         CODE:
1228                 char *str;
1229                 STRLEN len;
1230                 str = SvPV(string,len);
1231                 glCallLists(len,GL_BYTE,str);
1232
1233 void
1234 glRasterPos ( x, y, z, ... )
1235         double x
1236         double y
1237         double z
1238         CODE:
1239                 if ( items == 4 ) {
1240                         double w = SvNV(ST(3));
1241                         glRasterPos4d(x,y,z,w);
1242                 } else {
1243                         glRasterPos3d(x,y,z);
1244                 }
1245
1246 void
1247 glBitmap ( width, height, x1, y1, x2, y2, data )
1248         Uint32 width
1249         Uint32 height
1250         double x1
1251         double y1
1252         double x2
1253         double y2
1254         char *data
1255         CODE:
1256                 glBitmap(width,height,x1,y1,x2,y2,data);
1257
1258 void
1259 glDrawPixels ( width, height, format, type, pixels )
1260         Uint32 width
1261         Uint32 height
1262         GLenum format
1263         GLenum type
1264         char *pixels
1265         CODE:
1266                 glDrawPixels(width,height,format,type,pixels);
1267
1268
1269 SV*
1270 glReadPixels ( x, y, width, height, format, type )
1271         Uint32 x
1272         Uint32 y
1273         Uint32 height
1274         Uint32 width
1275         GLenum format
1276         GLenum type
1277         CODE:
1278                 int len, size;
1279                 char *buf;
1280                 size = 1;       /* ALPHA, BLUE, GREEN or RED */
1281                 if (format == GL_BGR || format == GL_RGB)
1282                         size = 3;
1283                 if (format == GL_BGRA || format == GL_RGBA)
1284                         size = 4;
1285                 len = height * width * size;            /* in bytes */
1286                 RETVAL = newSV(len);                    /* alloc len+1 bytes */
1287                 SvPOK_on(RETVAL);                       /* make an PV */
1288                 buf = SvPVX(RETVAL);                    /* get ptr to buffer */
1289                 glReadPixels(x,y,width,height,format,type,buf);
1290                 SvCUR_set(RETVAL, len);                 /* set real length */
1291         OUTPUT:
1292                 RETVAL
1293
1294 AV*
1295 glReadPixel ( x, y )
1296         Uint32 x
1297         Uint32 y
1298         CODE:
1299                 int rgba[4];    /* r,g,b,a */
1300                 int i;
1301                 glReadPixels(x,y,1,1,GL_RGBA,GL_UNSIGNED_INT,rgba);
1302                 RETVAL = newAV();
1303                 for ( i = 0; i < 4; i++ ) {
1304                         av_push(RETVAL,newSViv(rgba[i]));
1305                 }
1306         OUTPUT:
1307                 RETVAL
1308
1309 void
1310 glCopyPixels ( x, y, width, height, buffer )
1311         Sint32 x
1312         Sint32 y
1313         Uint32 width
1314         Uint32 height
1315         GLenum buffer
1316         CODE:
1317                 glCopyPixels(x,y,width,height,buffer);
1318
1319 void
1320 glPixelStore ( name, param )
1321         Sint32 name
1322         double param
1323         CODE:
1324                 glPixelStorei(name,param);
1325
1326 void
1327 glPixelTransfer ( name, ... )
1328         GLenum name
1329         CODE:
1330                 switch ( name ) {
1331                         case GL_MAP_COLOR:
1332                         case GL_MAP_STENCIL:
1333                         case GL_INDEX_SHIFT:
1334                         case GL_INDEX_OFFSET:
1335                                 glPixelTransferi(name,SvIV(ST(1)));
1336                                 break;
1337                         default:
1338                                 glPixelTransferf(name,SvNV(ST(1)));
1339                                 break;
1340                 }
1341
1342 void
1343 glPixelMap ( type, map, mapsize, values )
1344         GLenum type
1345         GLenum map
1346         Sint32 mapsize
1347         char *values
1348         CODE:
1349                 switch (type) {
1350                         case GL_UNSIGNED_INT:
1351                                 glPixelMapuiv(map,mapsize,(GLint*)values);
1352                                 break;
1353                         case GL_UNSIGNED_SHORT:
1354                                 glPixelMapusv(map,mapsize,(GLushort*)values);
1355                                 break;
1356                         case GL_FLOAT:
1357                                 glPixelMapfv(map,mapsize,(GLfloat*)values);
1358                                 break;
1359                 }
1360
1361 void
1362 glPixelZoom ( zoomx, zoomy )
1363         double zoomx
1364         double zoomy
1365         CODE:
1366                 glPixelZoom(zoomx,zoomy);
1367
1368 #ifdef GL_VERSION_1_3
1369
1370 void
1371 glColorTable ( target, internalFormat, width, format, type, data )
1372         GLenum target
1373         GLenum internalFormat
1374         Uint32 width
1375         GLenum format
1376         GLenum type
1377         char *data
1378         CODE:
1379                 glColorTable(target,internalFormat,width,format,type,data);
1380
1381 void
1382 glColorTableParameter ( target, name, r, g, b, a)
1383         GLenum target
1384         GLenum name
1385         double r
1386         double g
1387         double b
1388         double a
1389         CODE:
1390                 GLfloat vec[4];
1391                 vec[0] = r;
1392                 vec[1] = g;
1393                 vec[2] = b;
1394                 vec[3] = a;
1395                 glColorTableParameterfv(target,name,vec);
1396
1397 void
1398 glCopyColorTable ( target, internalFormat, x, y, width )
1399         GLenum target
1400         GLenum internalFormat
1401         Sint32 x
1402         Sint32 y
1403         Uint32 width
1404         CODE:
1405                 glCopyColorTable(target,internalFormat,x,y,width);
1406
1407 void
1408 glColorSubTable ( target, start, count, format, type, data )
1409         Uint32 target
1410         Uint32 start
1411         Uint32 count
1412         Uint32 format
1413         Uint32 type
1414         char *data
1415         CODE:
1416                 glColorSubTable(target,start,count,format,type,data);
1417
1418 void
1419 glCopyColorSubTable ( target, start, x, y, count )
1420         Uint32 target
1421         Uint32 start
1422         Sint32 x
1423         Sint32 y
1424         Uint32 count
1425         CODE:
1426                 glCopyColorSubTable(target,start,x,y,count);
1427
1428 void
1429 glConvolutionFilter2D ( target, internalFormat, width, height, format, type, image )
1430         Uint32 target
1431         Uint32 internalFormat
1432         Uint32 width
1433         Uint32 height
1434         Uint32 format
1435         Uint32 type
1436         char *image
1437         CODE:
1438                 glConvolutionFilter2D(target,internalFormat,width,height,format,type,image);
1439
1440 void
1441 glCopyConvolutionFilter2D ( target, internalFormat, x, y, width, height )
1442         Uint32 target
1443         Uint32 internalFormat
1444         Sint32 x
1445         Sint32 y
1446         Uint32 width
1447         Uint32 height
1448         CODE:
1449                 glCopyConvolutionFilter2D(target,internalFormat,x,y,width,height);
1450
1451 void
1452 glSeparableFilter2D ( target, internalFormat, width, height, format, type, row, column )
1453         Uint32 target
1454         Uint32 internalFormat
1455         Uint32 width
1456         Uint32 height
1457         Uint32 format
1458         Uint32 type
1459         char *row
1460         char *column
1461         CODE:
1462                 glSeparableFilter2D(target,internalFormat,width,height,format,type,row,column);
1463
1464 void
1465 glConvolutionFilter1D ( target, internalFormat, width, format, type, image )
1466         Uint32 target
1467         Uint32 internalFormat
1468         Uint32 width
1469         Uint32 format
1470         Uint32 type
1471         char *image
1472         CODE:
1473                 glConvolutionFilter1D(target,internalFormat,width,format,type,image);
1474
1475 void
1476 glCopyConvolutionFilter1D ( target, internalFormat, x, y, width )
1477         Uint32 target
1478         Uint32 internalFormat
1479         Sint32 x
1480         Sint32 y
1481         Uint32 width
1482         CODE:
1483                 glCopyConvolutionFilter1D(target,internalFormat,x,y,width);
1484
1485 void
1486 glConvolutionParameter ( target, pname, ... )
1487         Uint32 target
1488         Uint32 pname
1489         CODE:
1490                 Uint32 pi;
1491                 GLfloat pv[4];
1492                 switch(pname) {
1493                 case GL_CONVOLUTION_BORDER_MODE:
1494                         if ( items != 3 )
1495                                 Perl_croak(aTHX_ "Usage: ConvolutionParameter(target,pname,...)");
1496                         pi = SvIV(ST(2));
1497                         glConvolutionParameteri(target,pname,pi);
1498                         break;
1499                 case GL_CONVOLUTION_FILTER_SCALE:
1500                 case GL_CONVOLUTION_FILTER_BIAS:
1501                         if ( items != 6 )
1502                                 Perl_croak(aTHX_ "Usage: ConvolutionParameter(target,pname,...)");
1503                         pv[0] = (GLfloat)SvNV(ST(2));
1504                         pv[1] = (GLfloat)SvNV(ST(3));
1505                         pv[2] = (GLfloat)SvNV(ST(4));
1506                         pv[3] = (GLfloat)SvNV(ST(5));
1507                         glConvolutionParameterfv(target,pname,pv);
1508                         break;
1509                 default:
1510                         Perl_croak(aTHX_ "ConvolutionParameter invalid parameter");
1511                         break;
1512                 }
1513
1514 void
1515 glHistogram ( target, width, internalFormat, sink )
1516         Uint32 target
1517         Uint32 width
1518         Uint32 internalFormat
1519         GLboolean sink
1520         CODE:
1521                 glHistogram(target,width,internalFormat,sink);
1522
1523 void
1524 glGetHistogram ( target, reset, format, type, values )
1525         Uint32 target
1526         GLboolean reset
1527         Uint32 format
1528         Uint32 type
1529         char *values
1530         CODE:
1531                 glGetHistogram(target,reset,format,type,values);
1532
1533 void
1534 glResetHistogram ( target )
1535         Uint32 target
1536         CODE:
1537                 glResetHistogram(target);
1538
1539 void
1540 glMinmax ( target, internalFormat, sink )
1541         Uint32 target
1542         Uint32 internalFormat
1543         GLboolean sink
1544         CODE:
1545                 glMinmax(target,internalFormat,sink);
1546
1547 void
1548 glGetMinmax ( target, reset, format, type, values )
1549         Uint32 target
1550         GLboolean reset
1551         Uint32 format
1552         Uint32 type
1553         char *values
1554         CODE:
1555                 glGetMinmax(target,reset,format,type,values);
1556
1557 void
1558 glResetMinmax ( target )
1559         Uint32 target
1560         CODE:
1561                 glResetMinmax(target);
1562
1563 void
1564 glBlendEquation ( mode )
1565         Uint32 mode
1566         CODE:
1567                 glBlendEquation(mode);
1568
1569 #endif // GL_VERSION_1_3
1570
1571 void
1572 glTexImage2D ( target, level, internalFormat, width, height, border, format, type, data )
1573         GLenum target
1574         Sint32 level
1575         Sint32 internalFormat
1576         Uint32 width
1577         Uint32 height
1578         Sint32 border
1579         GLenum format
1580         GLenum type
1581         char *data
1582         CODE:
1583                 glTexImage2D(target,level,internalFormat,width,height,border,format,type,data);
1584
1585 void
1586 glCopyTexImage2D ( target, level, internalFormat, x, y, width, height, border )
1587         GLenum target
1588         Sint32 level
1589         Sint32 internalFormat
1590         Sint32 x
1591         Sint32 y
1592         Uint32 width
1593         Uint32 height
1594         Sint32 border
1595         CODE:
1596                 glCopyTexImage2D(target,level,internalFormat,x,y,width,height,border);
1597
1598 void
1599 glTexSubImage2D ( target, level, xoffset, yoffset, width, height, format, type, data )
1600         GLenum target
1601         Sint32 level
1602         Sint32 xoffset
1603         Sint32 yoffset
1604         Uint32 width
1605         Uint32 height
1606         GLenum format
1607         GLenum type
1608         char *data
1609         CODE:
1610                 glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,data);
1611
1612 void
1613 glCopyTexSubImage2D ( target, level, xoffset, yoffset, x, y, width, height )
1614         GLenum target
1615         Sint32 level
1616         Sint32 xoffset
1617         Sint32 yoffset
1618         Sint32 x
1619         Sint32 y
1620         Uint32 width
1621         Uint32 height
1622         CODE:
1623                 glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
1624
1625 void
1626 glTexImage1D ( target, level, internalFormat, width, border, format, type, data )
1627         GLenum target
1628         Sint32 level
1629         Sint32 internalFormat
1630         Uint32 width
1631         Sint32 border
1632         GLenum format
1633         GLenum type
1634         char *data
1635         CODE:
1636                 glTexImage1D(target,level,internalFormat,width,border,format,type,data);
1637
1638 void
1639 glTexSubImage1D ( target, level, xoffset, width, format, type, data )
1640         GLenum target
1641         Sint32 level
1642         Sint32 xoffset
1643         Uint32 width
1644         GLenum format
1645         GLenum type
1646         char *data
1647         CODE:
1648                 glTexSubImage1D(target,level,xoffset,width,format,type,data);
1649
1650 void
1651 glCopyTexImage1D ( target, level, internalFormat, x, y, width, border )
1652         GLenum target
1653         Sint32 level
1654         Sint32 internalFormat
1655         Sint32 x
1656         Sint32 y
1657         Uint32 width
1658         Sint32 border
1659         CODE:
1660                 glCopyTexImage1D(target,level,internalFormat,x,y,width,border);
1661
1662 void
1663 glCopyTexSubImage1D ( target, level, xoffset, x, y, width )
1664         GLenum target
1665         Sint32 level
1666         Sint32 xoffset
1667         Sint32 x
1668         Sint32 y
1669         Uint32 width
1670         CODE:
1671                 glCopyTexSubImage1D(target,level,xoffset,x,y,width);
1672
1673 #ifdef GL_VERSION_1_3
1674
1675 void
1676 glTexImage3D ( target, level, internalFormat, width, height, depth, border, format, type, data )
1677         GLenum target
1678         Sint32 level
1679         Sint32 internalFormat
1680         Uint32 width
1681         Uint32 height
1682         Uint32 depth
1683         Sint32 border
1684         GLenum format
1685         GLenum type
1686         char *data
1687         CODE:
1688                 glTexImage3D(target,level,internalFormat,width,height,depth,border,format,type,data);
1689
1690 void
1691 glTexSubImage3D ( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data )
1692         GLenum target
1693         Sint32 level
1694         Sint32 xoffset
1695         Sint32 yoffset
1696         Sint32 zoffset
1697         Uint32 width
1698         Uint32 height
1699         Uint32 depth
1700         GLenum format
1701         GLenum type
1702         char *data
1703         CODE:
1704                 glTexSubImage3D(target,level,xoffset,yoffset,zoffset,
1705                         width,height,depth,format,type,data);
1706
1707 void
1708 glCopyTexSubImage3D ( target, level, xoffset, yoffset, zoffset, x, y, width, height )
1709         GLenum target
1710         Sint32 level
1711         Sint32 xoffset
1712         Sint32 yoffset
1713         Sint32 zoffset
1714         Sint32 x
1715         Sint32 y
1716         Uint32 width
1717         Uint32 height
1718         CODE:
1719                 glCopyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height);
1720
1721 #endif // GL_VERSION_1_3
1722
1723 AV*
1724 glGenTextures ( n )
1725         Uint32 n;
1726         CODE:
1727                 Uint32 i;
1728                 Uint32 *names;
1729                 names = (Uint32*)safemalloc(sizeof(Uint32)*n);
1730                 RETVAL = newAV();
1731                 glGenTextures(n,names);
1732                 for ( i = 0; i < n; i++ ) {
1733                         av_push(RETVAL,newSViv(names[i]));
1734                 }
1735                 safefree(names);
1736         OUTPUT:
1737                 RETVAL
1738
1739 GLboolean
1740 glIsTexture ( texture )
1741         Uint32 texture
1742         CODE:
1743                 RETVAL = glIsTexture(texture);
1744         OUTPUT:
1745                 RETVAL
1746
1747 void
1748 glBindTexture ( target, texture )
1749         GLenum target
1750         Uint32 texture
1751         CODE:
1752                 glBindTexture(target,texture);
1753
1754 void
1755 glDeleteTextures ( ... )
1756         CODE:
1757                 Uint32 *textures;
1758                 int i;
1759                 textures = (Uint32*)safemalloc(sizeof(Uint32) * items);
1760                 if ( textures ) {
1761                         for ( i = 0; i < items; i++ ) {
1762                                 textures[i] = SvIV(ST(i));
1763                         }
1764                 }
1765                 glDeleteTextures(items,textures);
1766                 safefree(textures);
1767
1768 AV*
1769 glAreTexturesResident ( ... )
1770         CODE:
1771                 Uint32 *textures;
1772                 GLboolean *homes;
1773                 int i;
1774                 RETVAL = newAV();
1775                 textures = (Uint32*)safemalloc(sizeof(Uint32) * items);
1776                 homes = (GLboolean*)safemalloc(sizeof(GLboolean) * items);
1777                 if ( textures ) {
1778                         for ( i = 0; i < items; i++ ) {
1779                                 textures[i] = SvIV(ST(i));
1780                         }
1781                 }
1782                 if ( GL_FALSE != glAreTexturesResident(items,textures,homes)) {
1783                         for (i = 0; i < items; i++ ) {
1784                                 av_push(RETVAL,newSViv(homes[i]));
1785                         }
1786                 }
1787                 safefree(homes);
1788                 safefree(textures);
1789         OUTPUT:
1790                 RETVAL
1791
1792 void
1793 glPrioritizeTextures ( n, names, priorities )
1794         Uint32 n
1795         char *names
1796         char *priorities
1797         CODE:
1798                 glPrioritizeTextures(n,(GLuint*)names,(const GLclampf *)priorities);
1799
1800 void
1801 glTexEnv ( target, name, ... )
1802         GLenum target
1803         GLenum name
1804         CODE:
1805                 float pv[4];
1806                 GLint p;
1807                 switch(name) {
1808                         case GL_TEXTURE_ENV_MODE:
1809                                 p = SvIV(ST(2));
1810                                 glTexEnvi(target,name,p);
1811                                 break;
1812                         case GL_TEXTURE_ENV_COLOR:
1813                                 pv[0] = SvNV(ST(2));
1814                                 pv[1] = SvNV(ST(3));
1815                                 pv[2] = SvNV(ST(4));
1816                                 pv[3] = SvNV(ST(5));
1817                                 glTexEnvfv(target,name,pv);
1818                                 break;
1819                 }
1820
1821 void
1822 glTexCoord ( ... )
1823         CODE:
1824                 double s,t,r,q;
1825                 if ( items < 1 || items > 4 )
1826                         Perl_croak (aTHX_ "usage: SDL::OpenGL::TexCoord(s,[t,[r,[q]]])");
1827                 s = t = r = 0.0;
1828                 q = 1.0;
1829                 switch(items) {
1830                         case 4:
1831                                 q = SvNV(ST(3));
1832                         case 3:
1833                                 r = SvNV(ST(2));
1834                         case 2:
1835                                 t = SvNV(ST(1));
1836                         case 1:
1837                                 s = SvNV(ST(0));
1838                 }
1839                 glTexCoord4d(s,t,r,q);
1840
1841 void
1842 glTexParameter ( target, name, ... )
1843         GLenum target
1844         GLenum name
1845         CODE:
1846                 GLfloat pv[4];
1847                 GLint p;
1848                 switch (name) {
1849                         case GL_TEXTURE_BORDER_COLOR:
1850                                 pv[0] = SvNV(ST(2));
1851                                 pv[1] = SvNV(ST(3));
1852                                 pv[2] = SvNV(ST(4));
1853                                 pv[3] = SvNV(ST(5));
1854                                 glTexParameterfv(target,name,pv);
1855                                 break;
1856                         case GL_TEXTURE_PRIORITY:
1857                         case GL_TEXTURE_MIN_LOD:
1858                         case GL_TEXTURE_MAX_LOD:
1859                                 pv[0] = SvNV(ST(2));
1860                                 glTexParameterf(target,name,pv[0]);
1861                                 break;
1862                         case GL_TEXTURE_BASE_LEVEL:
1863                         case GL_TEXTURE_MAX_LEVEL:
1864                         default:
1865                                 p = SvIV(ST(2));
1866                                 glTexParameteri(target,name,p);
1867                                 break;
1868                 }
1869
1870 void
1871 glTexGen ( coord, name, ... )
1872         GLenum coord
1873         GLenum name
1874         CODE:
1875                 GLdouble *pv;
1876                 GLint p;
1877                 int i;
1878                 switch (name) {
1879                         case GL_TEXTURE_GEN_MODE:
1880                                 p = SvIV(ST(2));
1881                                 glTexGeni(coord,name,p);
1882                                 break;
1883                         default:
1884                                 if ( items == 2 )
1885                                         Perl_croak(aTHX_  "usage: glTexGen(coord,name,...)");
1886                                 pv = (GLdouble*)safemalloc(sizeof(GLdouble)*(items-2));
1887                                 for ( i = 0; i < items - 2; i++ ) {
1888                                         pv[i] = SvNV(ST(i+2));
1889                                 }
1890                                 glTexGendv(coord,name,pv);
1891                                 safefree(pv);
1892                                 break;
1893                 }
1894
1895 #ifdef GL_VERSION_1_3
1896
1897 void
1898 glActiveTextureARB ( texUnit )
1899         GLenum texUnit
1900         CODE:
1901                 glActiveTextureARB(texUnit);
1902
1903 void
1904 glMultiTexCoord ( texUnit,  ... )
1905         Uint32 texUnit
1906         CODE:
1907                 double s,t,r,q;
1908                 if ( items < 2 || items > 5 )
1909                         Perl_croak (aTHX_ "usage: SDL::OpenGL::MultiTexCoord(tex,s,[t,[r,[q]]])");
1910                 s = t = r = 0.0;
1911                 q = 1.0;
1912                 switch(items) {
1913                         case 5:
1914                                 q = SvNV(ST(3));
1915                         case 4:
1916                                 r = SvNV(ST(2));
1917                         case 3:
1918                                 t = SvNV(ST(1));
1919                         case 2:
1920                                 s = SvNV(ST(0));
1921                 }
1922                 glMultiTexCoord4dARB(texUnit,s,t,r,q);
1923
1924 #endif // GL_VERSION_1_3
1925
1926 void
1927 glDrawBuffer ( mode )
1928         GLenum mode
1929         CODE:
1930                 glDrawBuffer(mode);
1931
1932 void
1933 glReadBuffer ( mode )
1934         GLenum mode
1935         CODE:
1936                 glReadBuffer(mode);
1937
1938 void
1939 glIndexMask ( mask )
1940         Uint32 mask
1941         CODE:
1942                 glIndexMask(mask);
1943
1944 void
1945 glColorMask ( red, green, blue, alpha )
1946         GLboolean red
1947         GLboolean green
1948         GLboolean blue
1949         GLboolean alpha
1950         CODE:
1951                 glColorMask(red,green,blue,alpha);
1952
1953 void
1954 glDepthMask ( flag )
1955         GLboolean flag
1956         CODE:
1957                 glDepthMask(flag);
1958
1959 void
1960 glStencilMask ( mask )
1961         Uint32 mask
1962         CODE:
1963                 glStencilMask(mask);
1964
1965 void
1966 glScissor ( x , y, width, height )
1967         Sint32 x
1968         Sint32 y
1969         Uint32 width
1970         Uint32 height
1971         CODE:
1972                 glScissor(x,y,width,height);
1973
1974 void
1975 glAlphaFunc ( func, ref )
1976         GLenum func
1977         double ref
1978         CODE:
1979                 glAlphaFunc(func,ref);
1980
1981 void
1982 glStencilFunc ( func, ref, mask )
1983         GLenum func
1984         Sint32 ref
1985         Uint32 mask
1986         CODE:
1987                 glStencilFunc(func,ref,mask);
1988
1989 void
1990 glStencilOp ( fail, zfail, zpass )
1991         GLenum fail
1992         GLenum zfail
1993         GLenum zpass
1994         CODE:
1995                 glStencilOp(fail,zfail,zpass);
1996
1997 void
1998 glDepthFunc ( func )
1999         GLenum func
2000         CODE:
2001                 glDepthFunc(func);
2002
2003 void
2004 glLogicOp ( opcode )
2005         GLenum opcode
2006         CODE:
2007                 glLogicOp(opcode);
2008
2009 void
2010 glAccum ( op, value )
2011         GLenum op
2012         double value
2013         CODE:
2014                 glAccum(op,value);
2015
2016 void
2017 glMap1 ( target, u1, u2, stride, order, points )
2018         GLenum target
2019         double u1
2020         double u2
2021         Sint32 stride
2022         Sint32 order
2023         char *points
2024         CODE:
2025                 glMap1d(target,u1,u2,stride,order,(double*)points);
2026
2027 void
2028 glEvalCoord1 ( u )
2029         double u
2030         CODE:
2031                 glEvalCoord1d(u);
2032
2033 void
2034 glMapGrid1 ( n, u1, u2 )
2035         Sint32 n
2036         double u1
2037         double u2
2038         CODE:
2039                 glMapGrid1d(n,u1,u2);
2040
2041 void
2042 glEvalMesh1 ( mode, p1, p2 )
2043         GLenum mode
2044         Sint32 p1
2045         Sint32 p2
2046         CODE:
2047                 glEvalMesh1(mode,p1,p2);
2048
2049 void
2050 glMap2 ( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points )
2051         GLenum target
2052         double u1
2053         double u2
2054         Sint32 ustride
2055         Sint32 uorder
2056         double v1
2057         double v2
2058         Sint32 vstride
2059         Sint32 vorder
2060         char *points
2061         CODE:
2062                 glMap2d(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,(double*)points);
2063
2064 void
2065 glEvalCoord2 ( u, v )
2066         double u
2067         double v
2068         CODE:
2069                 glEvalCoord2d(u,v);
2070
2071 void
2072 glMapGrid2 ( nu, u1, u2, nv, v1, v2 )
2073         Sint32 nu
2074         double u1
2075         double u2
2076         Sint32 nv
2077         double v1
2078         double v2
2079         CODE:
2080                 glMapGrid2d(nu,u1,u2,nv,v1,v2);
2081
2082 void
2083 glEvalMesh2 ( mode, i1, i2, j1, j2 )
2084         GLenum mode
2085         Sint32 i1
2086         Sint32 i2
2087         Sint32 j1
2088         Sint32 j2
2089         CODE:
2090                 glEvalMesh2(mode,i1,i2,j1,j2);
2091
2092 GLenum
2093 glGetError ( )
2094         CODE:
2095                 RETVAL = glGetError();
2096         OUTPUT:
2097                 RETVAL
2098
2099 GLint
2100 glRenderMode ( mode )
2101         GLenum mode
2102         CODE:
2103                 RETVAL = glRenderMode( mode );
2104         OUTPUT:
2105                 RETVAL
2106
2107 void
2108 glInitNames ( )
2109         CODE:
2110                 glInitNames();
2111
2112 void
2113 glPushName ( name )
2114         GLuint name
2115         CODE:
2116                 glPushName(name);
2117
2118 void
2119 glPopName ( )
2120         CODE:
2121                 glPopName();
2122
2123 void
2124 glLoadName ( name )
2125         GLuint name
2126         CODE:
2127                 glLoadName(name);
2128
2129 void
2130 glFeedbackBuffer ( size, type, buffer )
2131         GLuint size
2132         GLenum type
2133         float* buffer
2134         CODE:
2135                 glFeedbackBuffer(size,type,buffer);
2136
2137 void
2138 glPassThrough ( token )
2139         GLfloat token
2140         CODE:
2141                 glPassThrough(token);
2142
2143
2144 #endif
2145
2146 #ifdef HAVE_GLU
2147
2148 void
2149 gluLookAt ( eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz )
2150         double eyex
2151         double eyey
2152         double eyez
2153         double centerx
2154         double centery
2155         double centerz
2156         double upx
2157         double upy
2158         double upz
2159         CODE:
2160                 gluLookAt(eyex,eyey,eyez,centerx,centery,centerz,upx,upy,upz);
2161
2162 void
2163 gluPerspective ( fovy, aspect, n, f )
2164         double fovy
2165         double aspect
2166         double n
2167         double f
2168         CODE:
2169                 gluPerspective(fovy,aspect,n,f);
2170
2171 void
2172 gluPickMatrix ( x, y, delx, dely, viewport )
2173         double x
2174         double y
2175         double delx
2176         double dely
2177         GLint* viewport
2178         CODE:
2179                 gluPickMatrix(x,y,delx,dely,viewport);
2180
2181 void
2182 gluOrtho2D ( left, right, bottom, top )
2183         double left
2184         double right
2185         double bottom
2186         double top
2187         CODE:
2188                 gluOrtho2D(left,right,bottom,top);
2189
2190 int
2191 gluScaleImage ( format, widthin, heightin, typein, datain, widthout, heightout, typeout, dataout )
2192         GLenum format
2193         Uint32 widthin
2194         Uint32 heightin
2195         GLenum typein
2196         char *datain
2197         Uint32 widthout
2198         Uint32 heightout
2199         GLenum typeout
2200         char *dataout
2201         CODE:
2202                 RETVAL = gluScaleImage(format,widthin,heightin,typein,datain,
2203                                 widthout,heightout,typeout,dataout);
2204         OUTPUT:
2205                 RETVAL
2206
2207 int
2208 gluBuild1DMipmaps ( target, internalFormat, width, format, type, data )
2209         GLenum target
2210         Sint32 internalFormat
2211         Uint32 width
2212         GLenum format
2213         GLenum type
2214         char *data
2215         CODE:
2216                 RETVAL = gluBuild1DMipmaps(target,internalFormat,width,format,type,data);
2217         OUTPUT:
2218                 RETVAL
2219
2220 int
2221 gluBuild2DMipmaps ( target, internalFormat, width, height, format, type, data )
2222         GLenum target
2223         Sint32 internalFormat
2224         Uint32 width
2225         Uint32 height
2226         GLenum format
2227         GLenum type
2228         char *data
2229         CODE:
2230                 RETVAL = gluBuild2DMipmaps(target,internalFormat,width,height,format,type,data);
2231         OUTPUT:
2232                 RETVAL
2233
2234
2235 #if HAVE_GLU_VERSION >= 12
2236 int
2237 gluBuild3DMipmaps ( target, internalFormat, width, height, depth, format, type, data )
2238         GLenum target
2239         Sint32 internalFormat
2240         Uint32 width
2241         Uint32 height
2242         Uint32 depth
2243         GLenum format
2244         GLenum type
2245         char *data
2246         CODE:
2247                 RETVAL = gluBuild3DMipmaps(target,internalFormat,width,height,depth,
2248                                 format,type,data);
2249         OUTPUT:
2250                 RETVAL
2251
2252 #else
2253 void
2254 gluBuild3DMipmaps ( )
2255         CODE:
2256                 Perl_croak (aTHX_ "SDL::OpenGL::Build3DMipmaps requires GLU 1.2");
2257
2258 #endif
2259
2260 #if HAVE_GLU_VERSION >= 12
2261 int
2262 gluBuild1DMipmapLevels ( target, internalFormat, width, format, type, level, base, max, data )
2263         GLenum target
2264         Sint32 internalFormat
2265         Uint32 width
2266         GLenum format
2267         GLenum type
2268         Sint32 level
2269         Sint32 base
2270         Sint32 max
2271         char *data
2272         CODE:
2273                 RETVAL = gluBuild1DMipmapLevels(target,internalFormat,width,
2274                                 format,type,level,base,max,data);
2275         OUTPUT:
2276                 RETVAL
2277
2278 #else
2279 void
2280 gluBuild1DMipmapLevels ()
2281         CODE:
2282                 Perl_croak(aTHX_ "SDL::OpenGL::Build1DMipmapLevels requires GLU 1.2");
2283
2284 #endif
2285
2286 #if HAVE_GLU_VERSION >= 12
2287 int
2288 gluBuild2DMipmapLevels ( target, internalFormat, width, height, format, type, level, base, max, data )
2289         GLenum target
2290         Sint32 internalFormat
2291         Uint32 width
2292         Uint32 height
2293         GLenum format
2294         GLenum type
2295         Sint32 level
2296         Sint32 base
2297         Sint32 max
2298         char *data
2299         CODE:
2300                 RETVAL = gluBuild2DMipmapLevels(target,internalFormat,width,height,
2301                                 format,type,level,base,max,data);
2302         OUTPUT:
2303                 RETVAL
2304
2305 #else
2306 void
2307 gluBuild2DMipmapLevels ()
2308         CODE:
2309                 Perl_croak(aTHX_ "SDL::OpenGL::Build2DMipmapLevels requires GLU 1.2");
2310
2311 #endif
2312
2313 #if HAVE_GLU_VERSION >= 12
2314 int
2315 gluBuild3DMipmapLevels ( target, internalFormat, width, height, depth, format, type, level, base, max, data )
2316         GLenum target
2317         Sint32 internalFormat
2318         Uint32 width
2319         Uint32 height
2320         Uint32 depth
2321         GLenum format
2322         GLenum type
2323         Sint32 level
2324         Sint32 base
2325         Sint32 max
2326         char *data
2327         CODE:
2328                 RETVAL = gluBuild3DMipmapLevels(target,internalFormat,width,height,depth,
2329                                 format,type,level,base,max,data);
2330         OUTPUT:
2331                 RETVAL
2332
2333 #else
2334 void
2335 gluBuild3DMipmapLevels ()
2336         CODE:
2337                 Perl_croak(aTHX_ "SDL::OpenGL::Build3DMipmapLevels requires GLU 1.2");
2338
2339 #endif
2340
2341 char*
2342 gluErrorString ( code )
2343         GLenum code
2344         CODE:
2345                 RETVAL = (char*)gluErrorString(code);
2346         OUTPUT:
2347                 RETVAL
2348
2349 GLUnurbsObj*
2350 gluNewNurbsRenderer ()
2351         CODE:
2352                 RETVAL = gluNewNurbsRenderer();
2353         OUTPUT:
2354                 RETVAL
2355
2356 void
2357 gluDeleteNurbsRenderer ( obj )
2358         GLUnurbsObj *obj
2359         CODE:
2360                 gluDeleteNurbsRenderer(obj);
2361
2362 void
2363 gluNurbsProperty ( obj, property, value )
2364         GLUnurbsObj *obj
2365         GLenum property
2366         double value
2367         CODE:
2368                 gluNurbsProperty(obj,property,(float)value);
2369
2370 void
2371 gluLoadSamplingMatrices ( obj, mm, pm, vp )
2372         GLUnurbsObj *obj
2373         char *mm
2374         char *pm
2375         char *vp
2376         CODE:
2377                 gluLoadSamplingMatrices(obj,(GLfloat*)mm,(GLfloat*)pm,(GLint*)vp);
2378
2379 double
2380 gluGetNurbsProperty ( obj, property )
2381         GLUnurbsObj *obj
2382         GLenum property
2383         CODE:
2384                 float f;
2385                 gluGetNurbsProperty(obj,property,&f);
2386                 RETVAL = (double)f;
2387         OUTPUT:
2388                 RETVAL
2389
2390 void
2391 gluNurbsCallback ( obj, which, cb )
2392         GLUnurbsObj *obj
2393         GLenum which
2394         SV *cb
2395         CODE:
2396                 switch(which) {
2397                         case GLU_ERROR:
2398                                 sdl_perl_nurbs_error_hook = cb;
2399                                 gluNurbsCallback(obj,GLU_ERROR,(GLvoid*)sdl_perl_nurbs_error_callback);
2400                                 break;
2401 #ifdef GLU_NURBS_BEGIN
2402                         case GLU_NURBS_BEGIN:
2403                         case GLU_NURBS_BEGIN_DATA:
2404                                 gluNurbsCallbackData(obj,(void*)cb);
2405                                 gluNurbsCallback(obj,GLU_NURBS_BEGIN_DATA,
2406                                         (GLvoid*)sdl_perl_nurbs_being_callback);
2407                                 break;
2408                         case GLU_NURBS_TEXTURE_COORD:
2409                         case GLU_NURBS_TEXTURE_COORD_DATA:
2410                                 gluNurbsCallbackData(obj,(void*)cb);
2411                                 gluNurbsCallback(obj,GLU_NURBS_TEXTURE_COORD_DATA,
2412                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
2413                                 break;
2414                         case GLU_NURBS_COLOR:
2415                         case GLU_NURBS_COLOR_DATA:
2416                                 gluNurbsCallbackData(obj,(void*)cb);
2417                                 gluNurbsCallback(obj,GLU_NURBS_COLOR_DATA,
2418                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
2419                                 break;
2420                         case GLU_NURBS_NORMAL:
2421                         case GLU_NURBS_NORMAL_DATA:
2422                                 gluNurbsCallbackData(obj,(void*)cb);
2423                                 gluNurbsCallback(obj,GLU_NURBS_NORMAL_DATA,
2424                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
2425                                 break;
2426                         case GLU_NURBS_VERTEX:
2427                         case GLU_NURBS_VERTEX_DATA:
2428                                 gluNurbsCallbackData(obj,(void*)cb);
2429                                 gluNurbsCallback(obj,GLU_NURBS_VERTEX_DATA,
2430                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
2431                                 break;
2432                         case GLU_NURBS_END:
2433                         case GLU_NURBS_END_DATA:
2434                                 gluNurbsCallbackData(obj,(void*)cb);
2435                                 gluNurbsCallback(obj,GLU_NURBS_END_DATA,
2436                                         (GLvoid*)sdl_perl_nurbs_end_callback);
2437                                 break;
2438 #endif
2439                         default:
2440                                 Perl_croak(aTHX_ "SDL::OpenGL::NurbsCallback - invalid type");
2441                 }
2442
2443 void
2444 gluNurbsCallbackData ( obj, cb )
2445         GLUnurbsObj *obj
2446         SV *cb
2447         CODE:
2448                 gluNurbsCallbackData(obj,(void*)cb);
2449
2450 void
2451 gluBeginSurface ( obj )
2452         GLUnurbsObj *obj
2453         CODE:
2454                 gluBeginSurface(obj);
2455
2456 void
2457 gluEndSurface ( obj )
2458         GLUnurbsObj *obj
2459         CODE:
2460                 gluEndSurface(obj);
2461
2462 void
2463 gluNurbsSurface ( obj, uknot_count, uknot, vknot_count, vknot, u_stride, v_stride, ctlarray, uorder, vorder, type )
2464         GLUnurbsObj *obj
2465         Sint32 uknot_count
2466         char *uknot
2467         Sint32 vknot_count
2468         char *vknot
2469         Sint32 u_stride
2470         Sint32 v_stride
2471         char *ctlarray
2472         Sint32 uorder
2473         Sint32 vorder
2474         GLenum type
2475         CODE:
2476                 gluNurbsSurface(obj,uknot_count,(GLfloat*)uknot,vknot_count,(GLfloat*)vknot,
2477                         u_stride,v_stride,(GLfloat*)ctlarray,uorder,vorder,type);
2478
2479 void
2480 gluBeginCurve ( obj )
2481         GLUnurbsObj *obj
2482         CODE:
2483                 gluBeginCurve(obj);
2484
2485 void
2486 gluEndCurve ( obj )
2487         GLUnurbsObj *obj
2488         CODE:
2489                 gluEndCurve(obj);
2490
2491 void
2492 gluNurbsCurve ( obj, uknot_count, uknot, u_stride, ctlarray, uorder, type )
2493         GLUnurbsObj *obj
2494         Sint32 uknot_count
2495         char *uknot
2496         Sint32 u_stride
2497         char *ctlarray
2498         Sint32 uorder
2499         GLenum type
2500         CODE:
2501                 gluNurbsCurve(obj,uknot_count,(GLfloat*)uknot,u_stride,(GLfloat*)ctlarray,
2502                         uorder,type);
2503
2504 void
2505 gluBeginTrim ( obj )
2506         GLUnurbsObj *obj
2507         CODE:
2508                 gluBeginTrim(obj);
2509
2510 void
2511 gluEndTrim ( obj )
2512         GLUnurbsObj *obj
2513         CODE:
2514                 gluEndTrim(obj);
2515
2516 void
2517 gluPwlCurve ( obj, count, array, stride, type )
2518         GLUnurbsObj *obj
2519         Sint32 count
2520         char *array
2521         Sint32 stride
2522         GLenum type
2523         CODE:
2524                 gluPwlCurve(obj,count,(GLfloat*)array,stride,type);
2525
2526 AV*
2527 gluUnProject ( winx, winy, winz, mm, pm, vp )
2528         double winx
2529         double winy
2530         double winz
2531         char *mm
2532         char *pm
2533         char *vp
2534         CODE:
2535                 GLdouble objx, objy, objz;
2536                 RETVAL = newAV();
2537                 av_push(RETVAL,newSViv(gluUnProject(winx,winy,winz,(GLdouble*)mm,
2538                         (GLdouble*)pm,(GLint*)vp,&objx,&objy,&objz)));
2539                 av_push(RETVAL,newSVnv((double)objx));
2540                 av_push(RETVAL,newSVnv((double)objy));
2541                 av_push(RETVAL,newSVnv((double)objz));
2542         OUTPUT:
2543                 RETVAL
2544
2545
2546 #ifdef GL_VERSION_1_3
2547
2548 AV*
2549 gluUnProject4 ( winx, winy, winz, clipw, mm, pm, vp, n, f )
2550         double winx
2551         double winy
2552         double winz
2553         double clipw
2554         char *mm
2555         char *pm
2556         char *vp
2557         double n
2558         double f
2559         CODE:
2560                 GLdouble objx, objy, objz, objw;
2561                 RETVAL = newAV();
2562                 av_push(RETVAL,newSViv(gluUnProject4(winx,winy,winz,clipw,(GLdouble*)mm,
2563                         (GLdouble*)pm,(GLint*)vp,(GLclampd)n,(GLclampd)f,
2564                         &objx,&objy,&objz,&objw)));
2565                 av_push(RETVAL,newSVnv((double)objx));
2566                 av_push(RETVAL,newSVnv((double)objy));
2567                 av_push(RETVAL,newSVnv((double)objz));
2568                 av_push(RETVAL,newSVnv((double)objw));
2569         OUTPUT:
2570                 RETVAL
2571
2572 #endif // GL_VERSION_1_3
2573
2574 AV*
2575 gluProject ( objx, objy, objz, mm, pm, vp )
2576         double objx
2577         double objy
2578         double objz
2579         char *mm
2580         char *pm
2581         char *vp
2582         CODE:
2583                 GLdouble winx, winy, winz;
2584                 RETVAL = newAV();
2585                 av_push(RETVAL,newSViv(gluUnProject(objx,objy,objz,(GLdouble*)mm,
2586                         (GLdouble*)pm,(GLint*)vp,&winx,&winy,&winz)));
2587                 av_push(RETVAL,newSVnv((double)winx));
2588                 av_push(RETVAL,newSVnv((double)winy));
2589                 av_push(RETVAL,newSVnv((double)winz));
2590         OUTPUT:
2591                 RETVAL
2592
2593 #ifdef GL_VERSION_1_2
2594
2595 GLUtesselator*
2596 gluNewTess ()
2597         CODE:
2598                 RETVAL = gluNewTess();
2599         OUTPUT:
2600                 RETVAL
2601
2602 void
2603 gluTessCallback ( tess, type )
2604         GLUtesselator *tess
2605         GLenum type
2606         CODE:
2607                 switch(type) {
2608                         case GLU_TESS_BEGIN:
2609                         case GLU_TESS_BEGIN_DATA:
2610                                 gluTessCallback(tess,GLU_TESS_BEGIN_DATA,
2611                                         (GLvoid*)sdl_perl_tess_begin_callback);
2612                                 break;
2613
2614                         case GLU_TESS_EDGE_FLAG:
2615                         case GLU_TESS_EDGE_FLAG_DATA:
2616                                 gluTessCallback(tess,GLU_TESS_EDGE_FLAG_DATA,
2617                                         (GLvoid*)sdl_perl_tess_edge_flag_callback);
2618                                 break;
2619
2620                         case GLU_TESS_VERTEX:
2621                         case GLU_TESS_VERTEX_DATA:
2622                                 gluTessCallback(tess,GLU_TESS_VERTEX_DATA,
2623                                         (GLvoid*)sdl_perl_tess_vertex_callback);
2624                                 break;
2625
2626                         case GLU_TESS_END:
2627                         case GLU_TESS_END_DATA:
2628                                 gluTessCallback(tess,GLU_TESS_END_DATA,
2629                                         (GLvoid*)sdl_perl_tess_end_callback);
2630                                 break;
2631
2632                         case GLU_TESS_COMBINE:
2633                         case GLU_TESS_COMBINE_DATA:
2634                                 gluTessCallback(tess,GLU_TESS_COMBINE_DATA,
2635                                         (GLvoid*)sdl_perl_tess_combine_callback);
2636                                 break;
2637
2638                         case GLU_TESS_ERROR:
2639                         case GLU_TESS_ERROR_DATA:
2640                                 gluTessCallback(tess,GLU_TESS_ERROR_DATA,
2641                                         (GLvoid*)sdl_perl_tess_error_callback);
2642                                 break;
2643                 }
2644
2645 void
2646 gluTessProperty ( tessobj, property, value )
2647         GLUtesselator *tessobj
2648         Uint32 property
2649         double value
2650         CODE:
2651                 gluTessProperty(tessobj,property,value);
2652
2653 double
2654 gluGetTessProperty ( tessobj, property )
2655         GLUtesselator *tessobj
2656         Uint32 property
2657         CODE:
2658                 gluGetTessProperty(tessobj,property,&RETVAL);
2659         OUTPUT:
2660                 RETVAL
2661
2662 void
2663 gluTessNormal ( tessobj, x, y, z )
2664         GLUtesselator *tessobj
2665         double x
2666         double y
2667         double z
2668         CODE:
2669                 gluTessNormal(tessobj,x,y,z);
2670
2671 void
2672 gluTessBeginPolygon ( tessobj, cb )
2673         GLUtesselator *tessobj
2674         SV *cb
2675         CODE:
2676                 gluTessBeginPolygon(tessobj,cb);
2677
2678 void
2679 gluTessEndPolygon ( tessobj )
2680         GLUtesselator *tessobj
2681         CODE:
2682                 gluTessEndPolygon(tessobj);
2683
2684 void
2685 gluTessBeginContour ( tessobj )
2686         GLUtesselator *tessobj
2687         CODE:
2688                 gluTessBeginContour(tessobj);
2689
2690 void
2691 gluTessEndContour ( tessobj )
2692         GLUtesselator *tessobj
2693         CODE:
2694                 gluTessEndContour(tessobj);
2695
2696 void
2697 gluDeleteTess ( tessobj )
2698         GLUtesselator *tessobj
2699         CODE:
2700                 gluDeleteTess(tessobj);
2701
2702 void
2703 gluTessVertex ( tessobj, coords, vd )
2704         GLUtesselator *tessobj
2705         char *coords
2706         char *vd
2707         CODE:
2708                 gluTessVertex(tessobj,(GLdouble*)coords,vd);
2709
2710
2711
2712 GLUquadric *
2713 gluNewQuadric ()
2714         CODE:
2715                 RETVAL = gluNewQuadric ();
2716         OUTPUT:
2717                 RETVAL
2718
2719 void
2720 gluDeleteQuadric (quad)
2721         GLUquadric      *quad
2722         CODE:
2723                 gluDeleteQuadric(quad);
2724
2725 void
2726 gluQuadricNormals ( quad, normal )
2727         GLUquadric *quad
2728         GLenum  normal
2729         CODE:
2730                 gluQuadricNormals(quad, normal);
2731
2732
2733 void
2734 gluQuadricTexture ( quad, texture )
2735         GLUquadric *quad
2736         GLboolean  texture
2737         CODE:
2738                 gluQuadricTexture ( quad, texture );
2739
2740 void
2741 gluCylinder ( quad, base, top, height, slices, stacks )
2742         GLUquadric *quad
2743         GLdouble  base
2744         GLdouble  top
2745         GLdouble  height
2746         GLint  slices
2747         GLint  stacks
2748         CODE:
2749                 gluCylinder ( quad, base, top, height, slices, stacks );
2750 void
2751 gluDisk ( quad, inner, outer, slices, loops )
2752         GLUquadric *quad
2753         GLdouble inner
2754         GLdouble outer
2755         GLint slices
2756         GLint loops
2757         CODE:
2758                 gluDisk ( quad, inner, outer, slices, loops );
2759
2760 void
2761 gluPartialDisk ( quad, inner, outer, slices, loops, start, sweep )
2762         GLUquadric *quad
2763         GLdouble inner
2764         GLdouble outer
2765         GLint slices
2766         GLint loops
2767         GLdouble start
2768         GLdouble sweep
2769
2770         CODE:
2771                 gluPartialDisk ( quad, inner, outer, slices, loops, start, sweep );
2772
2773 void
2774 gluSphere ( quad, radius, slices, stacks )
2775         GLUquadric *quad
2776         GLdouble radius
2777         GLint  slices
2778         GLint  stacks
2779         CODE:
2780                 gluSphere ( quad, radius, slices, stacks );
2781
2782 #endif
2783