src/OpenGL.xs

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