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