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         {
 674             GLint ret[1];
 675             int i;
 676             glGetIntegerv(param, ret);
 677
 678             for (i = 0; i < 1; i++) {
 679                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 680             }
 681             break;
 682         }
 683         case GL_POLYGON_MODE:
 684         case GL_MAX_VIEWPORT_DIMS:
 685         case GL_MAP2_GRID_SEGMENTS:
 686         {
 687             GLint ret[2];
 688             int i;
 689             glGetIntegerv(param, ret);
 690
 691             for (i = 0; i < 2; i++) {
 692                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 693             }
 694             break;
 695         }
 696         case GL_SCISSOR_BOX:
 697         case GL_VIEWPORT:
 698         {
 699             GLint ret[4];
 700             int i;
 701             glGetIntegerv(param, ret);
 702
 703             for (i = 0; i < 4; i++) {
 704                 XPUSHs(sv_2mortal(newSViv(ret[i])));
 705             }
 706             break;
 707         }
 708         default:
 709             croak("Unknown glGet parameter!");
 710         }
 711
 712 const char * glGetString ( name )
 713         GLenum name
 714         CODE:
 715                 RETVAL = (const char *)glGetString (name);
 716         OUTPUT:
 717                 RETVAL
 718
 719 Uint32
 720 glIsEnabled ( cap )
 721         Uint32 cap
 722         CODE:
 723                 RETVAL = glIsEnabled(cap);
 724         OUTPUT:
 725                 RETVAL
 726
 727 void
 728 glPointSize ( size )
 729         double size
 730         CODE:
 731                 glPointSize((GLfloat)size);
 732
 733 void
 734 glLineWidth ( size )
 735         double size
 736         CODE:
 737                 glLineWidth((GLfloat)size);
 738
 739 void
 740 glLineStipple ( factor, pattern )
 741         Sint32 factor
 742         Uint16 pattern
 743         CODE:
 744                 glLineStipple(factor,pattern);
 745
 746 void
 747 glPolygonMode ( face, mode )
 748         GLenum face
 749         GLenum mode
 750         CODE:
 751                 glPolygonMode(face,mode);
 752
 753 void
 754 glFrontFace ( mode )
 755         GLenum mode
 756         CODE:
 757                 glFrontFace(mode);
 758
 759 void
 760 glCullFace ( mode )
 761         GLenum mode
 762         CODE:
 763                 glCullFace(mode);
 764
 765 void
 766 glPolygonStipple ( mask )
 767         char *mask
 768         CODE:
 769                 glPolygonStipple(mask);
 770
 771 void
 772 glEdgeFlag ( flag )
 773         GLenum flag
 774         CODE:
 775                 glEdgeFlag(flag);
 776
 777 void
 778 glNormal ( x, y, z )
 779         double x
 780         double y
 781         double z
 782         CODE:
 783                 glNormal3d(x,y,z);
 784
 785 void
 786 glEnableClientState ( array )
 787         GLenum array
 788         CODE:
 789                 glEnableClientState(array);
 790
 791 void
 792 glDisableClientState ( array )
 793         GLenum array
 794         CODE:
 795                 glDisableClientState(array);
 796
 797 void
 798 glVertexPointer ( size, type, stride, pointer)
 799         int size
 800         GLenum type
 801         Uint32 stride
 802         char *pointer
 803         CODE:
 804                 glVertexPointer(size,type,stride,pointer);
 805
 806 void
 807 glColorPointer ( size, type, stride, pointer )
 808         Sint32 size
 809         GLenum type
 810         Uint32 stride
 811         char *pointer
 812         CODE:
 813                 glColorPointer(size,type,stride,pointer);
 814
 815 void
 816 glNormalPointer ( type, stride, pointer )
 817         GLenum type
 818         Uint32 stride
 819         char *pointer
 820         CODE:
 821                 glNormalPointer(type,stride,pointer);
 822
 823 void
 824 glTexCoordPointer ( size, type, stride, pointer )
 825         Sint32 size
 826         GLenum type
 827         Uint32 stride
 828         char *pointer
 829         CODE:
 830                 glTexCoordPointer(size,type,stride,pointer);
 831
 832 void
 833 glEdgeFlagPointer ( stride, pointer )
 834         Uint32 stride
 835         char *pointer
 836         CODE:
 837                 glEdgeFlagPointer(stride,pointer);
 838
 839 void
 840 glArrayElement ( ith )
 841         Uint32 ith
 842         CODE:
 843                 glArrayElement(ith);
 844
 845 void
 846 glDrawElements ( mode, count, type, indices )
 847         GLenum mode
 848         Uint32 count
 849         GLenum type
 850         char *indices
 851         CODE:
 852                 glDrawElements( mode, count, type, indices);
 853
 854 void
 855 glDrawRangeElements ( mode, start, end, count, type, indices )
 856         GLenum mode
 857         Uint32 start
 858         Uint32 end
 859         Uint32 count
 860         GLenum type
 861         char *indices
 862         CODE:
 863                 glDrawRangeElements(mode,start,end,count,type,indices);
 864
 865 void
 866 glDrawArrays ( mode, first, count )
 867         GLenum mode
 868         Uint32 first
 869         Uint32 count
 870         CODE:
 871                 glDrawArrays(mode,first,count);
 872
 873 void
 874 glInterleavedArrays ( format, stride, pointer )
 875         GLenum format
 876         Uint32 stride
 877         char *pointer
 878         CODE:
 879                 glInterleavedArrays(format,stride,pointer);
 880
 881 void
 882 glPushAttrib ( mask )
 883         GLbitfield mask
 884         CODE:
 885                 glPushAttrib(mask);
 886
 887 void
 888 glPopAttrib ()
 889         CODE:
 890                 glPopAttrib();
 891
 892 void
 893 glPushClientAttrib ( mask )
 894         GLbitfield mask
 895         CODE:
 896                 glPushClientAttrib(mask);
 897
 898 void
 899 glPopClientAttrib ()
 900         CODE:
 901                 glPopClientAttrib();
 902
 903 void
 904 glMatrixMode ( mode )
 905         GLenum mode
 906         CODE:
 907                 glMatrixMode(mode);
 908
 909 void
 910 glLoadIdentity ()
 911         CODE:
 912                 glLoadIdentity();
 913
 914 void
 915 glLoadMatrix (  ... )
 916         CODE:
 917                 int i;
 918                 double mat[16];
 919                 for ( i = 0; i < 16; i++ ) {
 920                         mat[i] = (i < items  && SvNOK(ST(i)) ? SvNV(ST(i)) : 0.0 );
 921                 }
 922                 glLoadMatrixd(mat);
 923
 924 void
 925 glMultMatrix ( ... )
 926         CODE:
 927                 int i;
 928                 double mat[16];
 929                 for ( i = 0; i < 16; i++ ) {
 930                         mat[i] = (i < items  && SvNOK(ST(i)) ? SvNV(ST(i)) : 0.0 );
 931                 }
 932                 glMultMatrixd(mat);
 933
 934 void
 935 glTranslate ( x, y, z )
 936         double x
 937         double y
 938         double z
 939         CODE:
 940                 glTranslated(x,y,z);
 941
 942 void
 943 glRotate ( angle, x, y, z )
 944         double angle
 945         double x
 946         double y
 947         double z
 948         CODE:
 949                 glRotated(angle,x,y,z);
 950
 951 void
 952 glScale ( x, y, z )
 953         double x
 954         double y
 955         double z
 956         CODE:
 957                 glScaled(x,y,z);
 958
 959 void
 960 glFrustum ( left, right, bottom, top, n, f )
 961         double left
 962         double right
 963         double bottom
 964         double top
 965         double n
 966         double f
 967         CODE:
 968                 glFrustum(left,right,bottom,top,n,f);
 969
 970 void
 971 glOrtho ( left, right, bottom, top, n, f )
 972         double left
 973         double right
 974         double bottom
 975         double top
 976         double n
 977         double f
 978         CODE:
 979                 glOrtho(left,right,bottom,top,n,f);
 980
 981 void
 982 glViewport ( x, y, width, height )
 983         Sint32 x
 984         Sint32 y
 985         Uint32 width
 986         Uint32 height
 987         CODE:
 988                 glViewport(x,y,width,height);
 989
 990 void
 991 glDepthRange ( n, f )
 992         double n
 993         double f
 994         CODE:
 995                 glDepthRange(n,f);
 996
 997 void
 998 glPushMatrix ()
 999         CODE:
1000                 glPushMatrix();
1001
1002 void
1003 glPopMatrix ()
1004         CODE:
1005                 glPopMatrix();
1006
1007 void
1008 glClipPlane ( plane, ... )
1009         GLenum plane
1010         CODE:
1011                 double v[4];
1012                 int i;
1013                 for (i = 0; i < 4; i++ ) {
1014                         v[i] = (i+1 < items && SvNOK(ST(i+1))) ? SvNV(ST(i+1)) : 0.0;
1015                 }
1016                 glClipPlane(plane,v);
1017
1018 void
1019 glColor ( r, g, b, ... )
1020         double r
1021         double g
1022         double b
1023         CODE:
1024                 if ( items == 4 ) {
1025                         double a;
1026                         a = SvNV(ST(3));
1027                         glColor4d(r,g,b,a);
1028                 } else {
1029                         glColor3d(r,g,b);
1030                 }
1031
1032 void
1033 glIndex ( c )
1034         Uint32 c
1035         CODE:
1036                 glIndexi(c);
1037
1038 void
1039 glShadeModel ( mode )
1040         GLenum mode
1041         CODE:
1042                 glShadeModel(mode);
1043
1044 void
1045 glLight ( light, name, ... )
1046         GLenum light
1047         GLenum name
1048         CODE:
1049                 int i;
1050                 if ( items == 6 ) {
1051                         float v[4];
1052                         for ( i = 0; i < 4; i++ ) {
1053                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1054                         }
1055                         glLightfv(light,name,v);
1056                 } else if ( items == 5 ) {
1057                         float v[3];
1058                         for ( i = 0; i < 3; i++ ) {
1059                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1060                         }
1061                         glLightfv(light,name,v);
1062                 } else if ( items == 3 ) {
1063                         float v;
1064                         v = SvNV(ST(2));
1065                         glLightf(light,name,v);
1066                 } else {
1067                         Perl_croak(aTHX_ "SDL::OpenGL::Light invalid arguments");
1068                 }
1069
1070 void
1071 glLightModel ( pname, ... )
1072         GLenum pname
1073         CODE:
1074                 GLfloat vec[4];
1075                 if ( pname == GL_LIGHT_MODEL_LOCAL_VIEWER ||
1076                         pname == GL_LIGHT_MODEL_TWO_SIDE ||
1077                         pname == GL_LIGHT_MODEL_COLOR_CONTROL ) {
1078                         glLightModelf(pname,SvNV(ST(1)));
1079                 } else if ( pname == GL_LIGHT_MODEL_AMBIENT) {
1080                         vec[0] = SvNV(ST(1));
1081                         vec[1] = SvNV(ST(2));
1082                         vec[2] = SvNV(ST(3));
1083                         vec[3] = SvNV(ST(4));
1084                         glLightModelfv(pname,vec);
1085                 } else {
1086                         Perl_croak(aTHX_ "SDL::OpenGL::glLightModel unknown model %d",pname);
1087                 }
1088
1089 void
1090 glMaterial ( face, name, ... )
1091         GLenum face
1092         GLenum name
1093         CODE:
1094                 int i;
1095                 if ( items == 6 ) {
1096                         float v[4];
1097                         for ( i = 0; i < 4; i++ ) {
1098                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1099                         }
1100                         glMaterialfv(face,name,v);
1101                 } else if ( items == 5 ) {
1102                         float v[3];
1103                         for ( i = 0; i < 4; i++ ) {
1104                                 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1105                         }
1106                         glMaterialfv(face,name,v);
1107                 } else if ( items == 3 ) {
1108                         float v;
1109                         v = SvNV(ST(2));
1110                         glMaterialf(face,name,v);
1111                 } else {
1112                         Perl_croak(aTHX_ "SDL::OpenGL::Material invalid arguments");
1113                 }
1114
1115 void
1116 glColorMaterial ( face, mode )
1117         GLenum face
1118         GLenum mode
1119         CODE:
1120                 glColorMaterial(face,mode);
1121
1122 void
1123 glBlendFunc ( sfactor, dfactor )
1124         GLenum sfactor
1125         GLenum dfactor
1126         CODE:
1127                 glBlendFunc(sfactor,dfactor);
1128
1129
1130 void
1131 glHint ( target, hint )
1132         GLenum target
1133         GLenum hint
1134         CODE:
1135                 glHint(target,hint);
1136
1137 void
1138 glFog ( name, ... )
1139         GLenum name
1140         CODE:
1141                 if ( items == 5 )  {
1142                         float v[4];
1143                         v[0] = SvNV(ST(1));
1144                         v[1] = SvNV(ST(2));
1145                         v[2] = SvNV(ST(3));
1146                         v[3] = SvNV(ST(4));
1147                         glFogfv(name,v);
1148                 } else if ( items == 2 ) {
1149                         float v;
1150                         v = SvNV(ST(1));
1151                         glFogf(name,v);
1152                 } else {
1153                         Perl_croak(aTHX_ "SDL::OpenGL::Material invalid arguments");
1154                 }
1155
1156 void
1157 glPolygonOffset ( factor, units )
1158         double factor
1159         double units
1160         CODE:
1161                 glPolygonOffset(factor,units);
1162
1163 Uint32
1164 glGenLists ( range )
1165         Uint32 range
1166         CODE:
1167                 RETVAL = glGenLists(range);
1168         OUTPUT:
1169                 RETVAL
1170
1171 void
1172 glNewList ( list, mode )
1173         Uint32 list
1174         GLenum mode
1175         CODE:
1176                 glNewList(list,mode);
1177
1178 void
1179 glEndList ()
1180         CODE:
1181                 glEndList();
1182
1183 void
1184 glDeleteLists ( base, count )
1185         Uint32 base
1186         Uint32 count
1187         CODE:
1188                 glDeleteLists(base, count);
1189
1190 void
1191 glCallList ( list )
1192         Uint32 list
1193         CODE:
1194                 glCallList(list);
1195
1196 Uint32
1197 glIsList ( list )
1198         Uint32 list
1199         CODE:
1200                 RETVAL = glIsList(list);
1201         OUTPUT:
1202                 RETVAL
1203
1204 void
1205 glListBase ( base )
1206         Uint32 base
1207         CODE:
1208                 glListBase(base);
1209
1210 void
1211 glCallLists ( ... )
1212         CODE:
1213                 int *i, j;
1214                 if ( items > 0 ) {
1215                         i = (int*)safemalloc(sizeof(int)* (items));
1216                         for ( j = 0; j < items; j++ ) {
1217                                 i[j] = SvIV(ST(j));
1218                         }
1219                 } else {
1220                         Perl_croak(aTHX_ "usage: SDL::OpenGL::CallLists(type,...)");
1221                 }
1222                 glCallLists(items, GL_INT, i);
1223                 safefree(i);
1224
1225 void
1226 glCallListsString ( string )
1227         SV* string
1228         CODE:
1229                 char *str;
1230                 STRLEN len;
1231                 str = SvPV(string,len);
1232                 glCallLists(len,GL_BYTE,str);
1233
1234 void
1235 glRasterPos ( x, y, ... )
1236         double x
1237         double y
1238         CODE:
1239                 if (items == 2)
1240                 {
1241                         glRasterPos2d (x,y);
1242                 }
1243                 else if (items == 3)
1244                 {
1245                         double z = SvNV (ST(2));
1246                         glRasterPos3d (x,y,z);
1247                 }
1248                 else if (items == 4)
1249                 {
1250                         double z = SvNV (ST(2));
1251                         double w = SvNV (ST(3));
1252                         glRasterPos4d (x,y,z,w);
1253                 }
1254
1255 void
1256 glBitmap ( width, height, x1, y1, x2, y2, data )
1257         Uint32 width
1258         Uint32 height
1259         double x1
1260         double y1
1261         double x2
1262         double y2
1263         char *data
1264         CODE:
1265                 glBitmap(width,height,x1,y1,x2,y2,data);
1266
1267 void
1268 glDrawPixels ( width, height, format, type, pixels )
1269         Uint32 width
1270         Uint32 height
1271         GLenum format
1272         GLenum type
1273         char *pixels
1274         CODE:
1275                 glDrawPixels(width,height,format,type,pixels);
1276
1277
1278 SV*
1279 glReadPixels ( x, y, width, height, format, type )
1280         Uint32 x
1281         Uint32 y
1282         Uint32 height
1283         Uint32 width
1284         GLenum format
1285         GLenum type
1286         CODE:
1287                 int len, size;
1288                 char *buf;
1289                 size = 1;       /* ALPHA, BLUE, GREEN or RED */
1290                 if (format == GL_BGR || format == GL_RGB)
1291                         size = 3;
1292                 if (format == GL_BGRA || format == GL_RGBA)
1293                         size = 4;
1294                 len = height * width * size;            /* in bytes */
1295                 RETVAL = newSV(len);                    /* alloc len+1 bytes */
1296                 SvPOK_on(RETVAL);                       /* make an PV */
1297                 buf = SvPVX(RETVAL);                    /* get ptr to buffer */
1298                 glReadPixels(x,y,width,height,format,type,buf);
1299                 SvCUR_set(RETVAL, len);                 /* set real length */
1300         OUTPUT:
1301                 RETVAL
1302
1303 AV*
1304 glReadPixel ( x, y )
1305         Uint32 x
1306         Uint32 y
1307         CODE:
1308                 int rgba[4];    /* r,g,b,a */
1309                 int i;
1310                 glReadPixels(x,y,1,1,GL_RGBA,GL_UNSIGNED_INT,rgba);
1311                 RETVAL = newAV();
1312                 for ( i = 0; i < 4; i++ ) {
1313                         av_push(RETVAL,newSViv(rgba[i]));
1314                 }
1315         OUTPUT:
1316                 RETVAL
1317
1318 void
1319 glCopyPixels ( x, y, width, height, buffer )
1320         Sint32 x
1321         Sint32 y
1322         Uint32 width
1323         Uint32 height
1324         GLenum buffer
1325         CODE:
1326                 glCopyPixels(x,y,width,height,buffer);
1327
1328 void
1329 glPixelStore ( name, param )
1330         Sint32 name
1331         double param
1332         CODE:
1333                 glPixelStorei(name,param);
1334
1335 void
1336 glPixelTransfer ( name, ... )
1337         GLenum name
1338         CODE:
1339                 switch ( name ) {
1340                         case GL_MAP_COLOR:
1341                         case GL_MAP_STENCIL:
1342                         case GL_INDEX_SHIFT:
1343                         case GL_INDEX_OFFSET:
1344                                 glPixelTransferi(name,SvIV(ST(1)));
1345                                 break;
1346                         default:
1347                                 glPixelTransferf(name,SvNV(ST(1)));
1348                                 break;
1349                 }
1350
1351 void
1352 glPixelMap ( type, map, mapsize, values )
1353         GLenum type
1354         GLenum map
1355         Sint32 mapsize
1356         char *values
1357         CODE:
1358                 switch (type) {
1359                         case GL_UNSIGNED_INT:
1360                                 glPixelMapuiv(map,mapsize,(GLint*)values);
1361                                 break;
1362                         case GL_UNSIGNED_SHORT:
1363                                 glPixelMapusv(map,mapsize,(GLushort*)values);
1364                                 break;
1365                         case GL_FLOAT:
1366                                 glPixelMapfv(map,mapsize,(GLfloat*)values);
1367                                 break;
1368                 }
1369
1370 void
1371 glPixelZoom ( zoomx, zoomy )
1372         double zoomx
1373         double zoomy
1374         CODE:
1375                 glPixelZoom(zoomx,zoomy);
1376
1377 #ifdef GL_VERSION_1_3
1378
1379 void
1380 glColorTable ( target, internalFormat, width, format, type, data )
1381         GLenum target
1382         GLenum internalFormat
1383         Uint32 width
1384         GLenum format
1385         GLenum type
1386         char *data
1387         CODE:
1388                 glColorTable(target,internalFormat,width,format,type,data);
1389
1390 void
1391 glColorTableParameter ( target, name, r, g, b, a)
1392         GLenum target
1393         GLenum name
1394         double r
1395         double g
1396         double b
1397         double a
1398         CODE:
1399                 GLfloat vec[4];
1400                 vec[0] = r;
1401                 vec[1] = g;
1402                 vec[2] = b;
1403                 vec[3] = a;
1404                 glColorTableParameterfv(target,name,vec);
1405
1406 void
1407 glCopyColorTable ( target, internalFormat, x, y, width )
1408         GLenum target
1409         GLenum internalFormat
1410         Sint32 x
1411         Sint32 y
1412         Uint32 width
1413         CODE:
1414                 glCopyColorTable(target,internalFormat,x,y,width);
1415
1416 void
1417 glColorSubTable ( target, start, count, format, type, data )
1418         Uint32 target
1419         Uint32 start
1420         Uint32 count
1421         Uint32 format
1422         Uint32 type
1423         char *data
1424         CODE:
1425                 glColorSubTable(target,start,count,format,type,data);
1426
1427 void
1428 glCopyColorSubTable ( target, start, x, y, count )
1429         Uint32 target
1430         Uint32 start
1431         Sint32 x
1432         Sint32 y
1433         Uint32 count
1434         CODE:
1435                 glCopyColorSubTable(target,start,x,y,count);
1436
1437 void
1438 glConvolutionFilter2D ( target, internalFormat, width, height, format, type, image )
1439         Uint32 target
1440         Uint32 internalFormat
1441         Uint32 width
1442         Uint32 height
1443         Uint32 format
1444         Uint32 type
1445         char *image
1446         CODE:
1447                 glConvolutionFilter2D(target,internalFormat,width,height,format,type,image);
1448
1449 void
1450 glCopyConvolutionFilter2D ( target, internalFormat, x, y, width, height )
1451         Uint32 target
1452         Uint32 internalFormat
1453         Sint32 x
1454         Sint32 y
1455         Uint32 width
1456         Uint32 height
1457         CODE:
1458                 glCopyConvolutionFilter2D(target,internalFormat,x,y,width,height);
1459
1460 void
1461 glSeparableFilter2D ( target, internalFormat, width, height, format, type, row, column )
1462         Uint32 target
1463         Uint32 internalFormat
1464         Uint32 width
1465         Uint32 height
1466         Uint32 format
1467         Uint32 type
1468         char *row
1469         char *column
1470         CODE:
1471                 glSeparableFilter2D(target,internalFormat,width,height,format,type,row,column);
1472
1473 void
1474 glConvolutionFilter1D ( target, internalFormat, width, format, type, image )
1475         Uint32 target
1476         Uint32 internalFormat
1477         Uint32 width
1478         Uint32 format
1479         Uint32 type
1480         char *image
1481         CODE:
1482                 glConvolutionFilter1D(target,internalFormat,width,format,type,image);
1483
1484 void
1485 glCopyConvolutionFilter1D ( target, internalFormat, x, y, width )
1486         Uint32 target
1487         Uint32 internalFormat
1488         Sint32 x
1489         Sint32 y
1490         Uint32 width
1491         CODE:
1492                 glCopyConvolutionFilter1D(target,internalFormat,x,y,width);
1493
1494 void
1495 glConvolutionParameter ( target, pname, ... )
1496         Uint32 target
1497         Uint32 pname
1498         CODE:
1499                 Uint32 pi;
1500                 GLfloat pv[4];
1501                 switch(pname) {
1502                 case GL_CONVOLUTION_BORDER_MODE:
1503                         if ( items != 3 )
1504                                 Perl_croak(aTHX_ "Usage: ConvolutionParameter(target,pname,...)");
1505                         pi = SvIV(ST(2));
1506                         glConvolutionParameteri(target,pname,pi);
1507                         break;
1508                 case GL_CONVOLUTION_FILTER_SCALE:
1509                 case GL_CONVOLUTION_FILTER_BIAS:
1510                         if ( items != 6 )
1511                                 Perl_croak(aTHX_ "Usage: ConvolutionParameter(target,pname,...)");
1512                         pv[0] = (GLfloat)SvNV(ST(2));
1513                         pv[1] = (GLfloat)SvNV(ST(3));
1514                         pv[2] = (GLfloat)SvNV(ST(4));
1515                         pv[3] = (GLfloat)SvNV(ST(5));
1516                         glConvolutionParameterfv(target,pname,pv);
1517                         break;
1518                 default:
1519                         Perl_croak(aTHX_ "ConvolutionParameter invalid parameter");
1520                         break;
1521                 }
1522
1523 void
1524 glHistogram ( target, width, internalFormat, sink )
1525         Uint32 target
1526         Uint32 width
1527         Uint32 internalFormat
1528         GLboolean sink
1529         CODE:
1530                 glHistogram(target,width,internalFormat,sink);
1531
1532 void
1533 glGetHistogram ( target, reset, format, type, values )
1534         Uint32 target
1535         GLboolean reset
1536         Uint32 format
1537         Uint32 type
1538         char *values
1539         CODE:
1540                 glGetHistogram(target,reset,format,type,values);
1541
1542 void
1543 glResetHistogram ( target )
1544         Uint32 target
1545         CODE:
1546                 glResetHistogram(target);
1547
1548 void
1549 glMinmax ( target, internalFormat, sink )
1550         Uint32 target
1551         Uint32 internalFormat
1552         GLboolean sink
1553         CODE:
1554                 glMinmax(target,internalFormat,sink);
1555
1556 void
1557 glGetMinmax ( target, reset, format, type, values )
1558         Uint32 target
1559         GLboolean reset
1560         Uint32 format
1561         Uint32 type
1562         char *values
1563         CODE:
1564                 glGetMinmax(target,reset,format,type,values);
1565
1566 void
1567 glResetMinmax ( target )
1568         Uint32 target
1569         CODE:
1570                 glResetMinmax(target);
1571
1572 void
1573 glBlendEquation ( mode )
1574         Uint32 mode
1575         CODE:
1576                 glBlendEquation(mode);
1577
1578 #endif // GL_VERSION_1_3
1579
1580 void
1581 glTexImage2D ( target, level, internalFormat, width, height, border, format, type, data )
1582         GLenum target
1583         Sint32 level
1584         Sint32 internalFormat
1585         Uint32 width
1586         Uint32 height
1587         Sint32 border
1588         GLenum format
1589         GLenum type
1590         char *data
1591         CODE:
1592                 glTexImage2D(target,level,internalFormat,width,height,border,format,type,data);
1593
1594 void
1595 glCopyTexImage2D ( target, level, internalFormat, x, y, width, height, border )
1596         GLenum target
1597         Sint32 level
1598         Sint32 internalFormat
1599         Sint32 x
1600         Sint32 y
1601         Uint32 width
1602         Uint32 height
1603         Sint32 border
1604         CODE:
1605                 glCopyTexImage2D(target,level,internalFormat,x,y,width,height,border);
1606
1607 void
1608 glTexSubImage2D ( target, level, xoffset, yoffset, width, height, format, type, data )
1609         GLenum target
1610         Sint32 level
1611         Sint32 xoffset
1612         Sint32 yoffset
1613         Uint32 width
1614         Uint32 height
1615         GLenum format
1616         GLenum type
1617         char *data
1618         CODE:
1619                 glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,data);
1620
1621 void
1622 glCopyTexSubImage2D ( target, level, xoffset, yoffset, x, y, width, height )
1623         GLenum target
1624         Sint32 level
1625         Sint32 xoffset
1626         Sint32 yoffset
1627         Sint32 x
1628         Sint32 y
1629         Uint32 width
1630         Uint32 height
1631         CODE:
1632                 glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
1633
1634 void
1635 glTexImage1D ( target, level, internalFormat, width, border, format, type, data )
1636         GLenum target
1637         Sint32 level
1638         Sint32 internalFormat
1639         Uint32 width
1640         Sint32 border
1641         GLenum format
1642         GLenum type
1643         char *data
1644         CODE:
1645                 glTexImage1D(target,level,internalFormat,width,border,format,type,data);
1646
1647 void
1648 glTexSubImage1D ( target, level, xoffset, width, format, type, data )
1649         GLenum target
1650         Sint32 level
1651         Sint32 xoffset
1652         Uint32 width
1653         GLenum format
1654         GLenum type
1655         char *data
1656         CODE:
1657                 glTexSubImage1D(target,level,xoffset,width,format,type,data);
1658
1659 void
1660 glCopyTexImage1D ( target, level, internalFormat, x, y, width, border )
1661         GLenum target
1662         Sint32 level
1663         Sint32 internalFormat
1664         Sint32 x
1665         Sint32 y
1666         Uint32 width
1667         Sint32 border
1668         CODE:
1669                 glCopyTexImage1D(target,level,internalFormat,x,y,width,border);
1670
1671 void
1672 glCopyTexSubImage1D ( target, level, xoffset, x, y, width )
1673         GLenum target
1674         Sint32 level
1675         Sint32 xoffset
1676         Sint32 x
1677         Sint32 y
1678         Uint32 width
1679         CODE:
1680                 glCopyTexSubImage1D(target,level,xoffset,x,y,width);
1681
1682 #ifdef GL_VERSION_1_3
1683
1684 void
1685 glTexImage3D ( target, level, internalFormat, width, height, depth, border, format, type, data )
1686         GLenum target
1687         Sint32 level
1688         Sint32 internalFormat
1689         Uint32 width
1690         Uint32 height
1691         Uint32 depth
1692         Sint32 border
1693         GLenum format
1694         GLenum type
1695         char *data
1696         CODE:
1697                 glTexImage3D(target,level,internalFormat,width,height,depth,border,format,type,data);
1698
1699 void
1700 glTexSubImage3D ( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data )
1701         GLenum target
1702         Sint32 level
1703         Sint32 xoffset
1704         Sint32 yoffset
1705         Sint32 zoffset
1706         Uint32 width
1707         Uint32 height
1708         Uint32 depth
1709         GLenum format
1710         GLenum type
1711         char *data
1712         CODE:
1713                 glTexSubImage3D(target,level,xoffset,yoffset,zoffset,
1714                         width,height,depth,format,type,data);
1715
1716 void
1717 glCopyTexSubImage3D ( target, level, xoffset, yoffset, zoffset, x, y, width, height )
1718         GLenum target
1719         Sint32 level
1720         Sint32 xoffset
1721         Sint32 yoffset
1722         Sint32 zoffset
1723         Sint32 x
1724         Sint32 y
1725         Uint32 width
1726         Uint32 height
1727         CODE:
1728                 glCopyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height);
1729
1730 #endif // GL_VERSION_1_3
1731
1732 AV*
1733 glGenTextures ( n )
1734         Uint32 n;
1735         CODE:
1736                 Uint32 i;
1737                 Uint32 *names;
1738                 names = (Uint32*)safemalloc(sizeof(Uint32)*n);
1739                 RETVAL = newAV();
1740                 glGenTextures(n,names);
1741                 for ( i = 0; i < n; i++ ) {
1742                         av_push(RETVAL,newSViv(names[i]));
1743                 }
1744                 safefree(names);
1745         OUTPUT:
1746                 RETVAL
1747
1748 GLboolean
1749 glIsTexture ( texture )
1750         Uint32 texture
1751         CODE:
1752                 RETVAL = glIsTexture(texture);
1753         OUTPUT:
1754                 RETVAL
1755
1756 void
1757 glBindTexture ( target, texture )
1758         GLenum target
1759         Uint32 texture
1760         CODE:
1761                 glBindTexture(target,texture);
1762
1763 void
1764 glDeleteTextures ( ... )
1765         CODE:
1766                 Uint32 *textures;
1767                 int i;
1768                 textures = (Uint32*)safemalloc(sizeof(Uint32) * items);
1769                 if ( textures ) {
1770                         for ( i = 0; i < items; i++ ) {
1771                                 textures[i] = SvIV(ST(i));
1772                         }
1773                 }
1774                 glDeleteTextures(items,textures);
1775                 safefree(textures);
1776
1777 AV*
1778 glAreTexturesResident ( ... )
1779         CODE:
1780                 Uint32 *textures;
1781                 GLboolean *homes;
1782                 int i;
1783                 RETVAL = newAV();
1784                 textures = (Uint32*)safemalloc(sizeof(Uint32) * items);
1785                 homes = (GLboolean*)safemalloc(sizeof(GLboolean) * items);
1786                 if ( textures ) {
1787                         for ( i = 0; i < items; i++ ) {
1788                                 textures[i] = SvIV(ST(i));
1789                         }
1790                 }
1791                 if ( GL_FALSE != glAreTexturesResident(items,textures,homes)) {
1792                         for (i = 0; i < items; i++ ) {
1793                                 av_push(RETVAL,newSViv(homes[i]));
1794                         }
1795                 }
1796                 safefree(homes);
1797                 safefree(textures);
1798         OUTPUT:
1799                 RETVAL
1800
1801 void
1802 glPrioritizeTextures ( n, names, priorities )
1803         Uint32 n
1804         char *names
1805         char *priorities
1806         CODE:
1807                 glPrioritizeTextures(n,(GLuint*)names,(const GLclampf *)priorities);
1808
1809 void
1810 glTexEnv ( target, name, ... )
1811         GLenum target
1812         GLenum name
1813         CODE:
1814                 float pv[4];
1815                 GLint p;
1816                 switch(name) {
1817                         case GL_TEXTURE_ENV_MODE:
1818                                 p = SvIV(ST(2));
1819                                 glTexEnvi(target,name,p);
1820                                 break;
1821                         case GL_TEXTURE_ENV_COLOR:
1822                                 pv[0] = SvNV(ST(2));
1823                                 pv[1] = SvNV(ST(3));
1824                                 pv[2] = SvNV(ST(4));
1825                                 pv[3] = SvNV(ST(5));
1826                                 glTexEnvfv(target,name,pv);
1827                                 break;
1828                 }
1829
1830 void
1831 glTexCoord ( ... )
1832         CODE:
1833                 double s,t,r,q;
1834                 if ( items < 1 || items > 4 )
1835                         Perl_croak (aTHX_ "usage: SDL::OpenGL::TexCoord(s,[t,[r,[q]]])");
1836                 s = t = r = 0.0;
1837                 q = 1.0;
1838                 switch(items) {
1839                         case 4:
1840                                 q = SvNV(ST(3));
1841                         case 3:
1842                                 r = SvNV(ST(2));
1843                         case 2:
1844                                 t = SvNV(ST(1));
1845                         case 1:
1846                                 s = SvNV(ST(0));
1847                 }
1848                 glTexCoord4d(s,t,r,q);
1849
1850 void
1851 glTexParameter ( target, name, ... )
1852         GLenum target
1853         GLenum name
1854         CODE:
1855                 GLfloat pv[4];
1856                 GLint p;
1857                 switch (name) {
1858                         case GL_TEXTURE_BORDER_COLOR:
1859                                 pv[0] = SvNV(ST(2));
1860                                 pv[1] = SvNV(ST(3));
1861                                 pv[2] = SvNV(ST(4));
1862                                 pv[3] = SvNV(ST(5));
1863                                 glTexParameterfv(target,name,pv);
1864                                 break;
1865                         case GL_TEXTURE_PRIORITY:
1866                         case GL_TEXTURE_MIN_LOD:
1867                         case GL_TEXTURE_MAX_LOD:
1868                                 pv[0] = SvNV(ST(2));
1869                                 glTexParameterf(target,name,pv[0]);
1870                                 break;
1871                         case GL_TEXTURE_BASE_LEVEL:
1872                         case GL_TEXTURE_MAX_LEVEL:
1873                         default:
1874                                 p = SvIV(ST(2));
1875                                 glTexParameteri(target,name,p);
1876                                 break;
1877                 }
1878
1879 void
1880 glTexGen ( coord, name, ... )
1881         GLenum coord
1882         GLenum name
1883         CODE:
1884                 GLdouble *pv;
1885                 GLint p;
1886                 int i;
1887                 switch (name) {
1888                         case GL_TEXTURE_GEN_MODE:
1889                                 p = SvIV(ST(2));
1890                                 glTexGeni(coord,name,p);
1891                                 break;
1892                         default:
1893                                 if ( items == 2 )
1894                                         Perl_croak(aTHX_  "usage: glTexGen(coord,name,...)");
1895                                 pv = (GLdouble*)safemalloc(sizeof(GLdouble)*(items-2));
1896                                 for ( i = 0; i < items - 2; i++ ) {
1897                                         pv[i] = SvNV(ST(i+2));
1898                                 }
1899                                 glTexGendv(coord,name,pv);
1900                                 safefree(pv);
1901                                 break;
1902                 }
1903
1904 #ifdef GL_VERSION_1_3
1905
1906 void
1907 glActiveTextureARB ( texUnit )
1908         GLenum texUnit
1909         CODE:
1910                 glActiveTextureARB(texUnit);
1911
1912 void
1913 glMultiTexCoord ( texUnit,  ... )
1914         Uint32 texUnit
1915         CODE:
1916                 double s,t,r,q;
1917                 if ( items < 2 || items > 5 )
1918                         Perl_croak (aTHX_ "usage: SDL::OpenGL::MultiTexCoord(tex,s,[t,[r,[q]]])");
1919                 s = t = r = 0.0;
1920                 q = 1.0;
1921                 switch(items) {
1922                         case 5:
1923                                 q = SvNV(ST(3));
1924                         case 4:
1925                                 r = SvNV(ST(2));
1926                         case 3:
1927                                 t = SvNV(ST(1));
1928                         case 2:
1929                                 s = SvNV(ST(0));
1930                 }
1931                 glMultiTexCoord4dARB(texUnit,s,t,r,q);
1932
1933 #endif // GL_VERSION_1_3
1934
1935 void
1936 glDrawBuffer ( mode )
1937         GLenum mode
1938         CODE:
1939                 glDrawBuffer(mode);
1940
1941 void
1942 glReadBuffer ( mode )
1943         GLenum mode
1944         CODE:
1945                 glReadBuffer(mode);
1946
1947 void
1948 glIndexMask ( mask )
1949         Uint32 mask
1950         CODE:
1951                 glIndexMask(mask);
1952
1953 void
1954 glColorMask ( red, green, blue, alpha )
1955         GLboolean red
1956         GLboolean green
1957         GLboolean blue
1958         GLboolean alpha
1959         CODE:
1960                 glColorMask(red,green,blue,alpha);
1961
1962 void
1963 glDepthMask ( flag )
1964         GLboolean flag
1965         CODE:
1966                 glDepthMask(flag);
1967
1968 void
1969 glStencilMask ( mask )
1970         Uint32 mask
1971         CODE:
1972                 glStencilMask(mask);
1973
1974 void
1975 glScissor ( x , y, width, height )
1976         Sint32 x
1977         Sint32 y
1978         Uint32 width
1979         Uint32 height
1980         CODE:
1981                 glScissor(x,y,width,height);
1982
1983 void
1984 glAlphaFunc ( func, ref )
1985         GLenum func
1986         double ref
1987         CODE:
1988                 glAlphaFunc(func,ref);
1989
1990 void
1991 glStencilFunc ( func, ref, mask )
1992         GLenum func
1993         Sint32 ref
1994         Uint32 mask
1995         CODE:
1996                 glStencilFunc(func,ref,mask);
1997
1998 void
1999 glStencilOp ( fail, zfail, zpass )
2000         GLenum fail
2001         GLenum zfail
2002         GLenum zpass
2003         CODE:
2004                 glStencilOp(fail,zfail,zpass);
2005
2006 void
2007 glDepthFunc ( func )
2008         GLenum func
2009         CODE:
2010                 glDepthFunc(func);
2011
2012 void
2013 glLogicOp ( opcode )
2014         GLenum opcode
2015         CODE:
2016                 glLogicOp(opcode);
2017
2018 void
2019 glAccum ( op, value )
2020         GLenum op
2021         double value
2022         CODE:
2023                 glAccum(op,value);
2024
2025 void
2026 glMap1 ( target, u1, u2, stride, order, points )
2027         GLenum target
2028         double u1
2029         double u2
2030         Sint32 stride
2031         Sint32 order
2032         char *points
2033         CODE:
2034                 glMap1d(target,u1,u2,stride,order,(double*)points);
2035
2036 void
2037 glEvalCoord1 ( u )
2038         double u
2039         CODE:
2040                 glEvalCoord1d(u);
2041
2042 void
2043 glMapGrid1 ( n, u1, u2 )
2044         Sint32 n
2045         double u1
2046         double u2
2047         CODE:
2048                 glMapGrid1d(n,u1,u2);
2049
2050 void
2051 glEvalMesh1 ( mode, p1, p2 )
2052         GLenum mode
2053         Sint32 p1
2054         Sint32 p2
2055         CODE:
2056                 glEvalMesh1(mode,p1,p2);
2057
2058 void
2059 glMap2 ( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points )
2060         GLenum target
2061         double u1
2062         double u2
2063         Sint32 ustride
2064         Sint32 uorder
2065         double v1
2066         double v2
2067         Sint32 vstride
2068         Sint32 vorder
2069         char *points
2070         CODE:
2071                 glMap2d(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,(double*)points);
2072
2073 void
2074 glEvalCoord2 ( u, v )
2075         double u
2076         double v
2077         CODE:
2078                 glEvalCoord2d(u,v);
2079
2080 void
2081 glMapGrid2 ( nu, u1, u2, nv, v1, v2 )
2082         Sint32 nu
2083         double u1
2084         double u2
2085         Sint32 nv
2086         double v1
2087         double v2
2088         CODE:
2089                 glMapGrid2d(nu,u1,u2,nv,v1,v2);
2090
2091 void
2092 glEvalMesh2 ( mode, i1, i2, j1, j2 )
2093         GLenum mode
2094         Sint32 i1
2095         Sint32 i2
2096         Sint32 j1
2097         Sint32 j2
2098         CODE:
2099                 glEvalMesh2(mode,i1,i2,j1,j2);
2100
2101 GLenum
2102 glGetError ( )
2103         CODE:
2104                 RETVAL = glGetError();
2105         OUTPUT:
2106                 RETVAL
2107
2108 GLint
2109 glRenderMode ( mode )
2110         GLenum mode
2111         CODE:
2112                 RETVAL = glRenderMode( mode );
2113         OUTPUT:
2114                 RETVAL
2115
2116 void
2117 glInitNames ( )
2118         CODE:
2119                 glInitNames();
2120
2121 void
2122 glPushName ( name )
2123         GLuint name
2124         CODE:
2125                 glPushName(name);
2126
2127 void
2128 glPopName ( )
2129         CODE:
2130                 glPopName();
2131
2132 void
2133 glLoadName ( name )
2134         GLuint name
2135         CODE:
2136                 glLoadName(name);
2137
2138 void
2139 glFeedbackBuffer ( size, type, buffer )
2140         GLuint size
2141         GLenum type
2142         float* buffer
2143         CODE:
2144                 glFeedbackBuffer(size,type,buffer);
2145
2146 void
2147 glPassThrough ( token )
2148         GLfloat token
2149         CODE:
2150                 glPassThrough(token);
2151
2152
2153 #endif
2154
2155 #ifdef HAVE_GLU
2156
2157 void
2158 gluLookAt ( eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz )
2159         double eyex
2160         double eyey
2161         double eyez
2162         double centerx
2163         double centery
2164         double centerz
2165         double upx
2166         double upy
2167         double upz
2168         CODE:
2169                 gluLookAt(eyex,eyey,eyez,centerx,centery,centerz,upx,upy,upz);
2170
2171 void
2172 gluPerspective ( fovy, aspect, n, f )
2173         double fovy
2174         double aspect
2175         double n
2176         double f
2177         CODE:
2178                 gluPerspective(fovy,aspect,n,f);
2179
2180 void
2181 gluPickMatrix ( x, y, delx, dely, viewport )
2182         double x
2183         double y
2184         double delx
2185         double dely
2186         GLint* viewport
2187         CODE:
2188                 gluPickMatrix(x,y,delx,dely,viewport);
2189
2190 void
2191 gluOrtho2D ( left, right, bottom, top )
2192         double left
2193         double right
2194         double bottom
2195         double top
2196         CODE:
2197                 gluOrtho2D(left,right,bottom,top);
2198
2199 int
2200 gluScaleImage ( format, widthin, heightin, typein, datain, widthout, heightout, typeout, dataout )
2201         GLenum format
2202         Uint32 widthin
2203         Uint32 heightin
2204         GLenum typein
2205         char *datain
2206         Uint32 widthout
2207         Uint32 heightout
2208         GLenum typeout
2209         char *dataout
2210         CODE:
2211                 RETVAL = gluScaleImage(format,widthin,heightin,typein,datain,
2212                                 widthout,heightout,typeout,dataout);
2213         OUTPUT:
2214                 RETVAL
2215
2216 int
2217 gluBuild1DMipmaps ( target, internalFormat, width, format, type, data )
2218         GLenum target
2219         Sint32 internalFormat
2220         Uint32 width
2221         GLenum format
2222         GLenum type
2223         char *data
2224         CODE:
2225                 RETVAL = gluBuild1DMipmaps(target,internalFormat,width,format,type,data);
2226         OUTPUT:
2227                 RETVAL
2228
2229 int
2230 gluBuild2DMipmaps ( target, internalFormat, width, height, format, type, data )
2231         GLenum target
2232         Sint32 internalFormat
2233         Uint32 width
2234         Uint32 height
2235         GLenum format
2236         GLenum type
2237         char *data
2238         CODE:
2239                 RETVAL = gluBuild2DMipmaps(target,internalFormat,width,height,format,type,data);
2240         OUTPUT:
2241                 RETVAL
2242
2243
2244 #if HAVE_GLU_VERSION >= 12
2245 int
2246 gluBuild3DMipmaps ( target, internalFormat, width, height, depth, format, type, data )
2247         GLenum target
2248         Sint32 internalFormat
2249         Uint32 width
2250         Uint32 height
2251         Uint32 depth
2252         GLenum format
2253         GLenum type
2254         char *data
2255         CODE:
2256                 RETVAL = gluBuild3DMipmaps(target,internalFormat,width,height,depth,
2257                                 format,type,data);
2258         OUTPUT:
2259                 RETVAL
2260
2261 #else
2262 void
2263 gluBuild3DMipmaps ( )
2264         CODE:
2265                 Perl_croak (aTHX_ "SDL::OpenGL::Build3DMipmaps requires GLU 1.2");
2266
2267 #endif
2268
2269 #if HAVE_GLU_VERSION >= 12
2270 int
2271 gluBuild1DMipmapLevels ( target, internalFormat, width, format, type, level, base, max, data )
2272         GLenum target
2273         Sint32 internalFormat
2274         Uint32 width
2275         GLenum format
2276         GLenum type
2277         Sint32 level
2278         Sint32 base
2279         Sint32 max
2280         char *data
2281         CODE:
2282                 RETVAL = gluBuild1DMipmapLevels(target,internalFormat,width,
2283                                 format,type,level,base,max,data);
2284         OUTPUT:
2285                 RETVAL
2286
2287 #else
2288 void
2289 gluBuild1DMipmapLevels ()
2290         CODE:
2291                 Perl_croak(aTHX_ "SDL::OpenGL::Build1DMipmapLevels requires GLU 1.2");
2292
2293 #endif
2294
2295 #if HAVE_GLU_VERSION >= 12
2296 int
2297 gluBuild2DMipmapLevels ( target, internalFormat, width, height, format, type, level, base, max, data )
2298         GLenum target
2299         Sint32 internalFormat
2300         Uint32 width
2301         Uint32 height
2302         GLenum format
2303         GLenum type
2304         Sint32 level
2305         Sint32 base
2306         Sint32 max
2307         char *data
2308         CODE:
2309                 RETVAL = gluBuild2DMipmapLevels(target,internalFormat,width,height,
2310                                 format,type,level,base,max,data);
2311         OUTPUT:
2312                 RETVAL
2313
2314 #else
2315 void
2316 gluBuild2DMipmapLevels ()
2317         CODE:
2318                 Perl_croak(aTHX_ "SDL::OpenGL::Build2DMipmapLevels requires GLU 1.2");
2319
2320 #endif
2321
2322 #if HAVE_GLU_VERSION >= 12
2323 int
2324 gluBuild3DMipmapLevels ( target, internalFormat, width, height, depth, format, type, level, base, max, data )
2325         GLenum target
2326         Sint32 internalFormat
2327         Uint32 width
2328         Uint32 height
2329         Uint32 depth
2330         GLenum format
2331         GLenum type
2332         Sint32 level
2333         Sint32 base
2334         Sint32 max
2335         char *data
2336         CODE:
2337                 RETVAL = gluBuild3DMipmapLevels(target,internalFormat,width,height,depth,
2338                                 format,type,level,base,max,data);
2339         OUTPUT:
2340                 RETVAL
2341
2342 #else
2343 void
2344 gluBuild3DMipmapLevels ()
2345         CODE:
2346                 Perl_croak(aTHX_ "SDL::OpenGL::Build3DMipmapLevels requires GLU 1.2");
2347
2348 #endif
2349
2350 char*
2351 gluErrorString ( code )
2352         GLenum code
2353         CODE:
2354                 RETVAL = (char*)gluErrorString(code);
2355         OUTPUT:
2356                 RETVAL
2357
2358 GLUnurbsObj*
2359 gluNewNurbsRenderer ()
2360         CODE:
2361                 RETVAL = gluNewNurbsRenderer();
2362         OUTPUT:
2363                 RETVAL
2364
2365 void
2366 gluDeleteNurbsRenderer ( obj )
2367         GLUnurbsObj *obj
2368         CODE:
2369                 gluDeleteNurbsRenderer(obj);
2370
2371 void
2372 gluNurbsProperty ( obj, property, value )
2373         GLUnurbsObj *obj
2374         GLenum property
2375         double value
2376         CODE:
2377                 gluNurbsProperty(obj,property,(float)value);
2378
2379 void
2380 gluLoadSamplingMatrices ( obj, mm, pm, vp )
2381         GLUnurbsObj *obj
2382         char *mm
2383         char *pm
2384         char *vp
2385         CODE:
2386                 gluLoadSamplingMatrices(obj,(GLfloat*)mm,(GLfloat*)pm,(GLint*)vp);
2387
2388 double
2389 gluGetNurbsProperty ( obj, property )
2390         GLUnurbsObj *obj
2391         GLenum property
2392         CODE:
2393                 float f;
2394                 gluGetNurbsProperty(obj,property,&f);
2395                 RETVAL = (double)f;
2396         OUTPUT:
2397                 RETVAL
2398
2399 void
2400 gluNurbsCallback ( obj, which, cb )
2401         GLUnurbsObj *obj
2402         GLenum which
2403         SV *cb
2404         CODE:
2405                 switch(which) {
2406                         case GLU_ERROR:
2407                                 sdl_perl_nurbs_error_hook = cb;
2408                                 gluNurbsCallback(obj,GLU_ERROR,(GLvoid*)sdl_perl_nurbs_error_callback);
2409                                 break;
2410 #ifdef GLU_NURBS_BEGIN
2411                         case GLU_NURBS_BEGIN:
2412                         case GLU_NURBS_BEGIN_DATA:
2413                                 gluNurbsCallbackData(obj,(void*)cb);
2414                                 gluNurbsCallback(obj,GLU_NURBS_BEGIN_DATA,
2415                                         (GLvoid*)sdl_perl_nurbs_being_callback);
2416                                 break;
2417                         case GLU_NURBS_TEXTURE_COORD:
2418                         case GLU_NURBS_TEXTURE_COORD_DATA:
2419                                 gluNurbsCallbackData(obj,(void*)cb);
2420                                 gluNurbsCallback(obj,GLU_NURBS_TEXTURE_COORD_DATA,
2421                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
2422                                 break;
2423                         case GLU_NURBS_COLOR:
2424                         case GLU_NURBS_COLOR_DATA:
2425                                 gluNurbsCallbackData(obj,(void*)cb);
2426                                 gluNurbsCallback(obj,GLU_NURBS_COLOR_DATA,
2427                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
2428                                 break;
2429                         case GLU_NURBS_NORMAL:
2430                         case GLU_NURBS_NORMAL_DATA:
2431                                 gluNurbsCallbackData(obj,(void*)cb);
2432                                 gluNurbsCallback(obj,GLU_NURBS_NORMAL_DATA,
2433                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
2434                                 break;
2435                         case GLU_NURBS_VERTEX:
2436                         case GLU_NURBS_VERTEX_DATA:
2437                                 gluNurbsCallbackData(obj,(void*)cb);
2438                                 gluNurbsCallback(obj,GLU_NURBS_VERTEX_DATA,
2439                                         (GLvoid*)sdl_perl_nurbs_multi_callback);
2440                                 break;
2441                         case GLU_NURBS_END:
2442                         case GLU_NURBS_END_DATA:
2443                                 gluNurbsCallbackData(obj,(void*)cb);
2444                                 gluNurbsCallback(obj,GLU_NURBS_END_DATA,
2445                                         (GLvoid*)sdl_perl_nurbs_end_callback);
2446                                 break;
2447 #endif
2448                         default:
2449                                 Perl_croak(aTHX_ "SDL::OpenGL::NurbsCallback - invalid type");
2450                 }
2451
2452 void
2453 gluNurbsCallbackData ( obj, cb )
2454         GLUnurbsObj *obj
2455         SV *cb
2456         CODE:
2457                 gluNurbsCallbackData(obj,(void*)cb);
2458
2459 void
2460 gluBeginSurface ( obj )
2461         GLUnurbsObj *obj
2462         CODE:
2463                 gluBeginSurface(obj);
2464
2465 void
2466 gluEndSurface ( obj )
2467         GLUnurbsObj *obj
2468         CODE:
2469                 gluEndSurface(obj);
2470
2471 void
2472 gluNurbsSurface ( obj, uknot_count, uknot, vknot_count, vknot, u_stride, v_stride, ctlarray, uorder, vorder, type )
2473         GLUnurbsObj *obj
2474         Sint32 uknot_count
2475         char *uknot
2476         Sint32 vknot_count
2477         char *vknot
2478         Sint32 u_stride
2479         Sint32 v_stride
2480         char *ctlarray
2481         Sint32 uorder
2482         Sint32 vorder
2483         GLenum type
2484         CODE:
2485                 gluNurbsSurface(obj,uknot_count,(GLfloat*)uknot,vknot_count,(GLfloat*)vknot,
2486                         u_stride,v_stride,(GLfloat*)ctlarray,uorder,vorder,type);
2487
2488 void
2489 gluBeginCurve ( obj )
2490         GLUnurbsObj *obj
2491         CODE:
2492                 gluBeginCurve(obj);
2493
2494 void
2495 gluEndCurve ( obj )
2496         GLUnurbsObj *obj
2497         CODE:
2498                 gluEndCurve(obj);
2499
2500 void
2501 gluNurbsCurve ( obj, uknot_count, uknot, u_stride, ctlarray, uorder, type )
2502         GLUnurbsObj *obj
2503         Sint32 uknot_count
2504         char *uknot
2505         Sint32 u_stride
2506         char *ctlarray
2507         Sint32 uorder
2508         GLenum type
2509         CODE:
2510                 gluNurbsCurve(obj,uknot_count,(GLfloat*)uknot,u_stride,(GLfloat*)ctlarray,
2511                         uorder,type);
2512
2513 void
2514 gluBeginTrim ( obj )
2515         GLUnurbsObj *obj
2516         CODE:
2517                 gluBeginTrim(obj);
2518
2519 void
2520 gluEndTrim ( obj )
2521         GLUnurbsObj *obj
2522         CODE:
2523                 gluEndTrim(obj);
2524
2525 void
2526 gluPwlCurve ( obj, count, array, stride, type )
2527         GLUnurbsObj *obj
2528         Sint32 count
2529         char *array
2530         Sint32 stride
2531         GLenum type
2532         CODE:
2533                 gluPwlCurve(obj,count,(GLfloat*)array,stride,type);
2534
2535 AV*
2536 gluUnProject ( winx, winy, winz, mm, pm, vp )
2537         double winx
2538         double winy
2539         double winz
2540         char *mm
2541         char *pm
2542         char *vp
2543         CODE:
2544                 GLdouble objx, objy, objz;
2545                 RETVAL = newAV();
2546                 av_push(RETVAL,newSViv(gluUnProject(winx,winy,winz,(GLdouble*)mm,
2547                         (GLdouble*)pm,(GLint*)vp,&objx,&objy,&objz)));
2548                 av_push(RETVAL,newSVnv((double)objx));
2549                 av_push(RETVAL,newSVnv((double)objy));
2550                 av_push(RETVAL,newSVnv((double)objz));
2551         OUTPUT:
2552                 RETVAL
2553
2554
2555 #ifdef GL_VERSION_1_3
2556
2557 AV*
2558 gluUnProject4 ( winx, winy, winz, clipw, mm, pm, vp, n, f )
2559         double winx
2560         double winy
2561         double winz
2562         double clipw
2563         char *mm
2564         char *pm
2565         char *vp
2566         double n
2567         double f
2568         CODE:
2569                 GLdouble objx, objy, objz, objw;
2570                 RETVAL = newAV();
2571                 av_push(RETVAL,newSViv(gluUnProject4(winx,winy,winz,clipw,(GLdouble*)mm,
2572                         (GLdouble*)pm,(GLint*)vp,(GLclampd)n,(GLclampd)f,
2573                         &objx,&objy,&objz,&objw)));
2574                 av_push(RETVAL,newSVnv((double)objx));
2575                 av_push(RETVAL,newSVnv((double)objy));
2576                 av_push(RETVAL,newSVnv((double)objz));
2577                 av_push(RETVAL,newSVnv((double)objw));
2578         OUTPUT:
2579                 RETVAL
2580
2581 #endif // GL_VERSION_1_3
2582
2583 AV*
2584 gluProject ( objx, objy, objz, mm, pm, vp )
2585         double objx
2586         double objy
2587         double objz
2588         char *mm
2589         char *pm
2590         char *vp
2591         CODE:
2592                 GLdouble winx, winy, winz;
2593                 RETVAL = newAV();
2594                 av_push(RETVAL,newSViv(gluUnProject(objx,objy,objz,(GLdouble*)mm,
2595                         (GLdouble*)pm,(GLint*)vp,&winx,&winy,&winz)));
2596                 av_push(RETVAL,newSVnv((double)winx));
2597                 av_push(RETVAL,newSVnv((double)winy));
2598                 av_push(RETVAL,newSVnv((double)winz));
2599         OUTPUT:
2600                 RETVAL
2601
2602 #ifdef GL_VERSION_1_2
2603
2604 GLUtesselator*
2605 gluNewTess ()
2606         CODE:
2607                 RETVAL = gluNewTess();
2608         OUTPUT:
2609                 RETVAL
2610
2611 void
2612 gluTessCallback ( tess, type )
2613         GLUtesselator *tess
2614         GLenum type
2615         CODE:
2616                 switch(type) {
2617                         case GLU_TESS_BEGIN:
2618                         case GLU_TESS_BEGIN_DATA:
2619                                 gluTessCallback(tess,GLU_TESS_BEGIN_DATA,
2620                                         (GLvoid*)sdl_perl_tess_begin_callback);
2621                                 break;
2622
2623                         case GLU_TESS_EDGE_FLAG:
2624                         case GLU_TESS_EDGE_FLAG_DATA:
2625                                 gluTessCallback(tess,GLU_TESS_EDGE_FLAG_DATA,
2626                                         (GLvoid*)sdl_perl_tess_edge_flag_callback);
2627                                 break;
2628
2629                         case GLU_TESS_VERTEX:
2630                         case GLU_TESS_VERTEX_DATA:
2631                                 gluTessCallback(tess,GLU_TESS_VERTEX_DATA,
2632                                         (GLvoid*)sdl_perl_tess_vertex_callback);
2633                                 break;
2634
2635                         case GLU_TESS_END:
2636                         case GLU_TESS_END_DATA:
2637                                 gluTessCallback(tess,GLU_TESS_END_DATA,
2638                                         (GLvoid*)sdl_perl_tess_end_callback);
2639                                 break;
2640
2641                         case GLU_TESS_COMBINE:
2642                         case GLU_TESS_COMBINE_DATA:
2643                                 gluTessCallback(tess,GLU_TESS_COMBINE_DATA,
2644                                         (GLvoid*)sdl_perl_tess_combine_callback);
2645                                 break;
2646
2647                         case GLU_TESS_ERROR:
2648                         case GLU_TESS_ERROR_DATA:
2649                                 gluTessCallback(tess,GLU_TESS_ERROR_DATA,
2650                                         (GLvoid*)sdl_perl_tess_error_callback);
2651                                 break;
2652                 }
2653
2654 void
2655 gluTessProperty ( tessobj, property, value )
2656         GLUtesselator *tessobj
2657         Uint32 property
2658         double value
2659         CODE:
2660                 gluTessProperty(tessobj,property,value);
2661
2662 double
2663 gluGetTessProperty ( tessobj, property )
2664         GLUtesselator *tessobj
2665         Uint32 property
2666         CODE:
2667                 gluGetTessProperty(tessobj,property,&RETVAL);
2668         OUTPUT:
2669                 RETVAL
2670
2671 void
2672 gluTessNormal ( tessobj, x, y, z )
2673         GLUtesselator *tessobj
2674         double x
2675         double y
2676         double z
2677         CODE:
2678                 gluTessNormal(tessobj,x,y,z);
2679
2680 void
2681 gluTessBeginPolygon ( tessobj, cb )
2682         GLUtesselator *tessobj
2683         SV *cb
2684         CODE:
2685                 gluTessBeginPolygon(tessobj,cb);
2686
2687 void
2688 gluTessEndPolygon ( tessobj )
2689         GLUtesselator *tessobj
2690         CODE:
2691                 gluTessEndPolygon(tessobj);
2692
2693 void
2694 gluTessBeginContour ( tessobj )
2695         GLUtesselator *tessobj
2696         CODE:
2697                 gluTessBeginContour(tessobj);
2698
2699 void
2700 gluTessEndContour ( tessobj )
2701         GLUtesselator *tessobj
2702         CODE:
2703                 gluTessEndContour(tessobj);
2704
2705 void
2706 gluDeleteTess ( tessobj )
2707         GLUtesselator *tessobj
2708         CODE:
2709                 gluDeleteTess(tessobj);
2710
2711 void
2712 gluTessVertex ( tessobj, coords, vd )
2713         GLUtesselator *tessobj
2714         char *coords
2715         char *vd
2716         CODE:
2717                 gluTessVertex(tessobj,(GLdouble*)coords,vd);
2718
2719 #endif
2720
2721 GLUquadric *
2722 gluNewQuadric ()
2723         CODE:
2724                 RETVAL = gluNewQuadric ();
2725         OUTPUT:
2726                 RETVAL
2727
2728 void
2729 gluDeleteQuadric (quad)
2730         GLUquadric      *quad
2731         CODE:
2732                 gluDeleteQuadric(quad);
2733
2734 void
2735 gluQuadricNormals ( quad, normal )
2736         GLUquadric *quad
2737         GLenum  normal
2738         CODE:
2739                 gluQuadricNormals(quad, normal);
2740
2741
2742 void
2743 gluQuadricTexture ( quad, texture )
2744         GLUquadric *quad
2745         GLboolean  texture
2746         CODE:
2747                 gluQuadricTexture ( quad, texture );
2748
2749 void
2750 gluCylinder ( quad, base, top, height, slices, stacks )
2751         GLUquadric *quad
2752         GLdouble  base
2753         GLdouble  top
2754         GLdouble  height
2755         GLint  slices
2756         GLint  stacks
2757         CODE:
2758                 gluCylinder ( quad, base, top, height, slices, stacks );
2759
2760 void
2761 gluDisk ( quad, inner, outer, slices, loops )
2762         GLUquadric *quad
2763         GLdouble inner
2764         GLdouble outer
2765         GLint slices
2766         GLint loops
2767         CODE:
2768                 gluDisk ( quad, inner, outer, slices, loops );
2769
2770 void
2771 gluPartialDisk ( quad, inner, outer, slices, loops, start, sweep )
2772         GLUquadric *quad
2773         GLdouble inner
2774         GLdouble outer
2775         GLint slices
2776         GLint loops
2777         GLdouble start
2778         GLdouble sweep
2779
2780         CODE:
2781                 gluPartialDisk ( quad, inner, outer, slices, loops, start, sweep );
2782
2783 void
2784 gluSphere ( quad, radius, slices, stacks )
2785         GLUquadric *quad
2786         GLdouble radius
2787         GLint  slices
2788         GLint  stacks
2789         CODE:
2790                 gluSphere ( quad, radius, slices, stacks );
2791
2792
2793
2794 void
2795 glXUseXFont ( font, first, count, list_base )
2796         Font font
2797         int  first
2798         int  count
2799         int  list_base
2800         CODE:
2801                 glXUseXFont ( font, first, count, list_base );
2802
2803 #endif
2804