src/OpenGL.xs

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