src/OpenGL.xs

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