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