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