src/OpenGL.xs

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