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