projects / sdlgit/SDL_perl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | history | HEAD
Applied Tels patch for faster Color.pm
[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:
673 {
674 GLint ret[1];
675 int i;
676 glGetIntegerv(param, ret);
677
678 for (i = 0; i < 1; i++) {
679 XPUSHs(sv_2mortal(newSViv(ret[i])));
680 }
681 break;
682 }
683 case GL_POLYGON_MODE:
684 case GL_MAX_VIEWPORT_DIMS:
685 case GL_MAP2_GRID_SEGMENTS:
686 {
687 GLint ret[2];
688 int i;
689 glGetIntegerv(param, ret);
690
691 for (i = 0; i < 2; i++) {
692 XPUSHs(sv_2mortal(newSViv(ret[i])));
693 }
694 break;
695 }
696 case GL_SCISSOR_BOX:
697 case GL_VIEWPORT:
698 {
699 GLint ret[4];
700 int i;
701 glGetIntegerv(param, ret);
702
703 for (i = 0; i < 4; i++) {
704 XPUSHs(sv_2mortal(newSViv(ret[i])));
705 }
706 break;
707 }
708 default:
709 croak("Unknown glGet parameter!");
710 }
711
4db254ce 712const char * glGetString ( name )
713 GLenum name
714 CODE:
715 RETVAL = (const char *)glGetString (name);
716 OUTPUT:
717 RETVAL
8fde61e3 718
719Uint32
720glIsEnabled ( cap )
721 Uint32 cap
722 CODE:
723 RETVAL = glIsEnabled(cap);
724 OUTPUT:
725 RETVAL
726
727void
728glPointSize ( size )
729 double size
730 CODE:
731 glPointSize((GLfloat)size);
732
733void
734glLineWidth ( size )
735 double size
736 CODE:
737 glLineWidth((GLfloat)size);
738
739void
740glLineStipple ( factor, pattern )
741 Sint32 factor
742 Uint16 pattern
743 CODE:
744 glLineStipple(factor,pattern);
745
746void
747glPolygonMode ( face, mode )
748 GLenum face
749 GLenum mode
750 CODE:
751 glPolygonMode(face,mode);
752
753void
754glFrontFace ( mode )
755 GLenum mode
756 CODE:
757 glFrontFace(mode);
758
759void
760glCullFace ( mode )
761 GLenum mode
762 CODE:
763 glCullFace(mode);
764
765void
766glPolygonStipple ( mask )
767 char *mask
768 CODE:
769 glPolygonStipple(mask);
770
771void
772glEdgeFlag ( flag )
773 GLenum flag
774 CODE:
775 glEdgeFlag(flag);
776
777void
778glNormal ( x, y, z )
779 double x
780 double y
781 double z
782 CODE:
783 glNormal3d(x,y,z);
784
785void
786glEnableClientState ( array )
787 GLenum array
788 CODE:
789 glEnableClientState(array);
790
791void
792glDisableClientState ( array )
793 GLenum array
794 CODE:
795 glDisableClientState(array);
796
797void
798glVertexPointer ( size, type, stride, pointer)
799 int size
800 GLenum type
801 Uint32 stride
802 char *pointer
803 CODE:
804 glVertexPointer(size,type,stride,pointer);
805
806void
807glColorPointer ( size, type, stride, pointer )
808 Sint32 size
809 GLenum type
810 Uint32 stride
811 char *pointer
812 CODE:
813 glColorPointer(size,type,stride,pointer);
814
815void
816glNormalPointer ( type, stride, pointer )
817 GLenum type
818 Uint32 stride
819 char *pointer
820 CODE:
821 glNormalPointer(type,stride,pointer);
822
823void
824glTexCoordPointer ( size, type, stride, pointer )
825 Sint32 size
826 GLenum type
827 Uint32 stride
828 char *pointer
829 CODE:
830 glTexCoordPointer(size,type,stride,pointer);
831
832void
833glEdgeFlagPointer ( stride, pointer )
834 Uint32 stride
835 char *pointer
836 CODE:
837 glEdgeFlagPointer(stride,pointer);
838
839void
840glArrayElement ( ith )
841 Uint32 ith
842 CODE:
843 glArrayElement(ith);
844
845void
846glDrawElements ( mode, count, type, indices )
847 GLenum mode
848 Uint32 count
849 GLenum type
850 char *indices
851 CODE:
852 glDrawElements( mode, count, type, indices);
853
854void
855glDrawRangeElements ( mode, start, end, count, type, indices )
856 GLenum mode
857 Uint32 start
858 Uint32 end
859 Uint32 count
860 GLenum type
861 char *indices
862 CODE:
863 glDrawRangeElements(mode,start,end,count,type,indices);
864
865void
866glDrawArrays ( mode, first, count )
867 GLenum mode
868 Uint32 first
869 Uint32 count
870 CODE:
871 glDrawArrays(mode,first,count);
872
873void
874glInterleavedArrays ( format, stride, pointer )
875 GLenum format
876 Uint32 stride
877 char *pointer
878 CODE:
879 glInterleavedArrays(format,stride,pointer);
880
881void
882glPushAttrib ( mask )
883 GLbitfield mask
884 CODE:
885 glPushAttrib(mask);
886
887void
888glPopAttrib ()
889 CODE:
890 glPopAttrib();
891
892void
893glPushClientAttrib ( mask )
894 GLbitfield mask
895 CODE:
896 glPushClientAttrib(mask);
897
898void
899glPopClientAttrib ()
900 CODE:
901 glPopClientAttrib();
902
903void
904glMatrixMode ( mode )
905 GLenum mode
906 CODE:
907 glMatrixMode(mode);
908
909void
910glLoadIdentity ()
911 CODE:
912 glLoadIdentity();
913
914void
915glLoadMatrix ( ... )
916 CODE:
917 int i;
918 double mat[16];
919 for ( i = 0; i < 16; i++ ) {
920 mat[i] = (i < items && SvNOK(ST(i)) ? SvNV(ST(i)) : 0.0 );
921 }
922 glLoadMatrixd(mat);
923
924void
925glMultMatrix ( ... )
926 CODE:
927 int i;
928 double mat[16];
929 for ( i = 0; i < 16; i++ ) {
930 mat[i] = (i < items && SvNOK(ST(i)) ? SvNV(ST(i)) : 0.0 );
931 }
932 glMultMatrixd(mat);
933
934void
935glTranslate ( x, y, z )
936 double x
937 double y
938 double z
939 CODE:
940 glTranslated(x,y,z);
941
942void
943glRotate ( angle, x, y, z )
944 double angle
945 double x
946 double y
947 double z
948 CODE:
949 glRotated(angle,x,y,z);
950
951void
952glScale ( x, y, z )
953 double x
954 double y
955 double z
956 CODE:
957 glScaled(x,y,z);
958
959void
960glFrustum ( left, right, bottom, top, n, f )
961 double left
962 double right
963 double bottom
964 double top
965 double n
966 double f
967 CODE:
968 glFrustum(left,right,bottom,top,n,f);
969
970void
971glOrtho ( left, right, bottom, top, n, f )
972 double left
973 double right
974 double bottom
975 double top
976 double n
977 double f
978 CODE:
979 glOrtho(left,right,bottom,top,n,f);
980
981void
982glViewport ( x, y, width, height )
983 Sint32 x
984 Sint32 y
985 Uint32 width
986 Uint32 height
987 CODE:
988 glViewport(x,y,width,height);
989
990void
991glDepthRange ( n, f )
992 double n
993 double f
994 CODE:
995 glDepthRange(n,f);
996
997void
998glPushMatrix ()
999 CODE:
1000 glPushMatrix();
1001
1002void
1003glPopMatrix ()
1004 CODE:
1005 glPopMatrix();
1006
1007void
1008glClipPlane ( plane, ... )
1009 GLenum plane
1010 CODE:
1011 double v[4];
1012 int i;
1013 for (i = 0; i < 4; i++ ) {
1014 v[i] = (i+1 < items && SvNOK(ST(i+1))) ? SvNV(ST(i+1)) : 0.0;
1015 }
1016 glClipPlane(plane,v);
1017
1018void
1019glColor ( r, g, b, ... )
1020 double r
1021 double g
1022 double b
1023 CODE:
1024 if ( items == 4 ) {
1025 double a;
1026 a = SvNV(ST(3));
1027 glColor4d(r,g,b,a);
1028 } else {
1029 glColor3d(r,g,b);
1030 }
1031
1032void
1033glIndex ( c )
1034 Uint32 c
1035 CODE:
1036 glIndexi(c);
1037
1038void
1039glShadeModel ( mode )
1040 GLenum mode
1041 CODE:
1042 glShadeModel(mode);
1043
1044void
1045glLight ( light, name, ... )
1046 GLenum light
1047 GLenum name
1048 CODE:
1049 int i;
1050 if ( items == 6 ) {
1051 float v[4];
1052 for ( i = 0; i < 4; i++ ) {
1053 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1054 }
1055 glLightfv(light,name,v);
1056 } else if ( items == 5 ) {
1057 float v[3];
1058 for ( i = 0; i < 3; i++ ) {
1059 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1060 }
1061 glLightfv(light,name,v);
1062 } else if ( items == 3 ) {
1063 float v;
1064 v = SvNV(ST(2));
1065 glLightf(light,name,v);
1066 } else {
1067 Perl_croak(aTHX_ "SDL::OpenGL::Light invalid arguments");
1068 }
1069
1070void
1071glLightModel ( pname, ... )
1072 GLenum pname
1073 CODE:
1074 GLfloat vec[4];
1075 if ( pname == GL_LIGHT_MODEL_LOCAL_VIEWER ||
1076 pname == GL_LIGHT_MODEL_TWO_SIDE ||
1077 pname == GL_LIGHT_MODEL_COLOR_CONTROL ) {
1078 glLightModelf(pname,SvNV(ST(1)));
1079 } else if ( pname == GL_LIGHT_MODEL_AMBIENT) {
1080 vec[0] = SvNV(ST(1));
1081 vec[1] = SvNV(ST(2));
1082 vec[2] = SvNV(ST(3));
1083 vec[3] = SvNV(ST(4));
1084 glLightModelfv(pname,vec);
1085 } else {
1086 Perl_croak(aTHX_ "SDL::OpenGL::glLightModel unknown model %d",pname);
1087 }
1088
1089void
1090glMaterial ( face, name, ... )
1091 GLenum face
1092 GLenum name
1093 CODE:
1094 int i;
1095 if ( items == 6 ) {
1096 float v[4];
1097 for ( i = 0; i < 4; i++ ) {
1098 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1099 }
1100 glMaterialfv(face,name,v);
1101 } else if ( items == 5 ) {
1102 float v[3];
1103 for ( i = 0; i < 4; i++ ) {
1104 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1105 }
1106 glMaterialfv(face,name,v);
1107 } else if ( items == 3 ) {
1108 float v;
1109 v = SvNV(ST(2));
1110 glMaterialf(face,name,v);
1111 } else {
1112 Perl_croak(aTHX_ "SDL::OpenGL::Material invalid arguments");
1113 }
1114
1115void
1116glColorMaterial ( face, mode )
1117 GLenum face
1118 GLenum mode
1119 CODE:
1120 glColorMaterial(face,mode);
1121
1122void
1123glBlendFunc ( sfactor, dfactor )
1124 GLenum sfactor
1125 GLenum dfactor
1126 CODE:
1127 glBlendFunc(sfactor,dfactor);
1128
1129
1130void
1131glHint ( target, hint )
1132 GLenum target
1133 GLenum hint
1134 CODE:
1135 glHint(target,hint);
1136
1137void
1138glFog ( name, ... )
1139 GLenum name
1140 CODE:
1141 if ( items == 5 ) {
1142 float v[4];
1143 v[0] = SvNV(ST(1));
1144 v[1] = SvNV(ST(2));
1145 v[2] = SvNV(ST(3));
1146 v[3] = SvNV(ST(4));
1147 glFogfv(name,v);
1148 } else if ( items == 2 ) {
1149 float v;
1150 v = SvNV(ST(1));
1151 glFogf(name,v);
1152 } else {
1153 Perl_croak(aTHX_ "SDL::OpenGL::Material invalid arguments");
1154 }
1155
1156void
1157glPolygonOffset ( factor, units )
1158 double factor
1159 double units
1160 CODE:
1161 glPolygonOffset(factor,units);
1162
1163Uint32
1164glGenLists ( range )
1165 Uint32 range
1166 CODE:
1167 RETVAL = glGenLists(range);
1168 OUTPUT:
1169 RETVAL
1170
1171void
1172glNewList ( list, mode )
1173 Uint32 list
1174 GLenum mode
1175 CODE:
1176 glNewList(list,mode);
1177
1178void
1179glEndList ()
1180 CODE:
1181 glEndList();
1182
1183void
1184glDeleteLists ( base, count )
1185 Uint32 base
1186 Uint32 count
1187 CODE:
1188 glDeleteLists(base, count);
1189
1190void
1191glCallList ( list )
1192 Uint32 list
1193 CODE:
1194 glCallList(list);
1195
1196Uint32
1197glIsList ( list )
1198 Uint32 list
1199 CODE:
1200 RETVAL = glIsList(list);
1201 OUTPUT:
1202 RETVAL
1203
1204void
1205glListBase ( base )
1206 Uint32 base
1207 CODE:
1208 glListBase(base);
1209
1210void
1211glCallLists ( ... )
1212 CODE:
1213 int *i, j;
1214 if ( items > 0 ) {
1215 i = (int*)safemalloc(sizeof(int)* (items));
1216 for ( j = 0; j < items; j++ ) {
1217 i[j] = SvIV(ST(j));
1218 }
1219 } else {
1220 Perl_croak(aTHX_ "usage: SDL::OpenGL::CallLists(type,...)");
1221 }
1222 glCallLists(items, GL_INT, i);
1223 safefree(i);
1224
1225void
1226glCallListsString ( string )
1227 SV* string
1228 CODE:
1229 char *str;
1230 STRLEN len;
1231 str = SvPV(string,len);
1232 glCallLists(len,GL_BYTE,str);
1233
1234void
4fb8d960 1235glRasterPos ( x, y, ... )
8fde61e3 1236 double x
1237 double y
8fde61e3 1238 CODE:
4fb8d960 1239 if (items == 2)
1240 {
1241 glRasterPos2d (x,y);
1242 }
1243 else if (items == 3)
1244 {
1245 double z = SvNV (ST(2));
1246 glRasterPos3d (x,y,z);
1247 }
1248 else if (items == 4)
1249 {
1250 double z = SvNV (ST(2));
1251 double w = SvNV (ST(3));
1252 glRasterPos4d (x,y,z,w);
8fde61e3 1253 }
1254
1255void
1256glBitmap ( width, height, x1, y1, x2, y2, data )
1257 Uint32 width
1258 Uint32 height
1259 double x1
1260 double y1
1261 double x2
1262 double y2
1263 char *data
1264 CODE:
1265 glBitmap(width,height,x1,y1,x2,y2,data);
1266
1267void
1268glDrawPixels ( width, height, format, type, pixels )
1269 Uint32 width
1270 Uint32 height
1271 GLenum format
1272 GLenum type
1273 char *pixels
1274 CODE:
1275 glDrawPixels(width,height,format,type,pixels);
1276
1277
1278SV*
1279glReadPixels ( x, y, width, height, format, type )
1280 Uint32 x
1281 Uint32 y
1282 Uint32 height
1283 Uint32 width
1284 GLenum format
1285 GLenum type
1286 CODE:
1287 int len, size;
1288 char *buf;
1289 size = 1; /* ALPHA, BLUE, GREEN or RED */
1290 if (format == GL_BGR || format == GL_RGB)
1291 size = 3;
1292 if (format == GL_BGRA || format == GL_RGBA)
1293 size = 4;
1294 len = height * width * size; /* in bytes */
1295 RETVAL = newSV(len); /* alloc len+1 bytes */
1296 SvPOK_on(RETVAL); /* make an PV */
1297 buf = SvPVX(RETVAL); /* get ptr to buffer */
1298 glReadPixels(x,y,width,height,format,type,buf);
1299 SvCUR_set(RETVAL, len); /* set real length */
1300 OUTPUT:
1301 RETVAL
1302
1303AV*
1304glReadPixel ( x, y )
1305 Uint32 x
1306 Uint32 y
1307 CODE:
1308 int rgba[4]; /* r,g,b,a */
1309 int i;
1310 glReadPixels(x,y,1,1,GL_RGBA,GL_UNSIGNED_INT,rgba);
1311 RETVAL = newAV();
1312 for ( i = 0; i < 4; i++ ) {
1313 av_push(RETVAL,newSViv(rgba[i]));
1314 }
1315 OUTPUT:
1316 RETVAL
1317
1318void
1319glCopyPixels ( x, y, width, height, buffer )
1320 Sint32 x
1321 Sint32 y
1322 Uint32 width
1323 Uint32 height
1324 GLenum buffer
1325 CODE:
1326 glCopyPixels(x,y,width,height,buffer);
1327
1328void
1329glPixelStore ( name, param )
1330 Sint32 name
1331 double param
1332 CODE:
1333 glPixelStorei(name,param);
1334
1335void
1336glPixelTransfer ( name, ... )
1337 GLenum name
1338 CODE:
1339 switch ( name ) {
1340 case GL_MAP_COLOR:
1341 case GL_MAP_STENCIL:
1342 case GL_INDEX_SHIFT:
1343 case GL_INDEX_OFFSET:
1344 glPixelTransferi(name,SvIV(ST(1)));
1345 break;
1346 default:
1347 glPixelTransferf(name,SvNV(ST(1)));
1348 break;
1349 }
1350
1351void
1352glPixelMap ( type, map, mapsize, values )
1353 GLenum type
1354 GLenum map
1355 Sint32 mapsize
1356 char *values
1357 CODE:
1358 switch (type) {
1359 case GL_UNSIGNED_INT:
1360 glPixelMapuiv(map,mapsize,(GLint*)values);
1361 break;
1362 case GL_UNSIGNED_SHORT:
1363 glPixelMapusv(map,mapsize,(GLushort*)values);
1364 break;
1365 case GL_FLOAT:
1366 glPixelMapfv(map,mapsize,(GLfloat*)values);
1367 break;
1368 }
1369
1370void
1371glPixelZoom ( zoomx, zoomy )
1372 double zoomx
1373 double zoomy
1374 CODE:
1375 glPixelZoom(zoomx,zoomy);
1376
1377#ifdef GL_VERSION_1_3
1378
1379void
1380glColorTable ( target, internalFormat, width, format, type, data )
1381 GLenum target
1382 GLenum internalFormat
1383 Uint32 width
1384 GLenum format
1385 GLenum type
1386 char *data
1387 CODE:
1388 glColorTable(target,internalFormat,width,format,type,data);
1389
1390void
1391glColorTableParameter ( target, name, r, g, b, a)
1392 GLenum target
1393 GLenum name
1394 double r
1395 double g
1396 double b
1397 double a
1398 CODE:
1399 GLfloat vec[4];
1400 vec[0] = r;
1401 vec[1] = g;
1402 vec[2] = b;
1403 vec[3] = a;
1404 glColorTableParameterfv(target,name,vec);
1405
1406void
1407glCopyColorTable ( target, internalFormat, x, y, width )
1408 GLenum target
1409 GLenum internalFormat
1410 Sint32 x
1411 Sint32 y
1412 Uint32 width
1413 CODE:
1414 glCopyColorTable(target,internalFormat,x,y,width);
1415
1416void
1417glColorSubTable ( target, start, count, format, type, data )
1418 Uint32 target
1419 Uint32 start
1420 Uint32 count
1421 Uint32 format
1422 Uint32 type
1423 char *data
1424 CODE:
1425 glColorSubTable(target,start,count,format,type,data);
1426
1427void
1428glCopyColorSubTable ( target, start, x, y, count )
1429 Uint32 target
1430 Uint32 start
1431 Sint32 x
1432 Sint32 y
1433 Uint32 count
1434 CODE:
1435 glCopyColorSubTable(target,start,x,y,count);
1436
1437void
1438glConvolutionFilter2D ( target, internalFormat, width, height, format, type, image )
1439 Uint32 target
1440 Uint32 internalFormat
1441 Uint32 width
1442 Uint32 height
1443 Uint32 format
1444 Uint32 type
1445 char *image
1446 CODE:
1447 glConvolutionFilter2D(target,internalFormat,width,height,format,type,image);
1448
1449void
1450glCopyConvolutionFilter2D ( target, internalFormat, x, y, width, height )
1451 Uint32 target
1452 Uint32 internalFormat
1453 Sint32 x
1454 Sint32 y
1455 Uint32 width
1456 Uint32 height
1457 CODE:
1458 glCopyConvolutionFilter2D(target,internalFormat,x,y,width,height);
1459
1460void
1461glSeparableFilter2D ( target, internalFormat, width, height, format, type, row, column )
1462 Uint32 target
1463 Uint32 internalFormat
1464 Uint32 width
1465 Uint32 height
1466 Uint32 format
1467 Uint32 type
1468 char *row
1469 char *column
1470 CODE:
1471 glSeparableFilter2D(target,internalFormat,width,height,format,type,row,column);
1472
1473void
1474glConvolutionFilter1D ( target, internalFormat, width, format, type, image )
1475 Uint32 target
1476 Uint32 internalFormat
1477 Uint32 width
1478 Uint32 format
1479 Uint32 type
1480 char *image
1481 CODE:
1482 glConvolutionFilter1D(target,internalFormat,width,format,type,image);
1483
1484void
1485glCopyConvolutionFilter1D ( target, internalFormat, x, y, width )
1486 Uint32 target
1487 Uint32 internalFormat
1488 Sint32 x
1489 Sint32 y
1490 Uint32 width
1491 CODE:
1492 glCopyConvolutionFilter1D(target,internalFormat,x,y,width);
1493
1494void
1495glConvolutionParameter ( target, pname, ... )
1496 Uint32 target
1497 Uint32 pname
1498 CODE:
1499 Uint32 pi;
1500 GLfloat pv[4];
1501 switch(pname) {
1502 case GL_CONVOLUTION_BORDER_MODE:
1503 if ( items != 3 )
1504 Perl_croak(aTHX_ "Usage: ConvolutionParameter(target,pname,...)");
1505 pi = SvIV(ST(2));
1506 glConvolutionParameteri(target,pname,pi);
1507 break;
1508 case GL_CONVOLUTION_FILTER_SCALE:
1509 case GL_CONVOLUTION_FILTER_BIAS:
1510 if ( items != 6 )
1511 Perl_croak(aTHX_ "Usage: ConvolutionParameter(target,pname,...)");
1512 pv[0] = (GLfloat)SvNV(ST(2));
1513 pv[1] = (GLfloat)SvNV(ST(3));
1514 pv[2] = (GLfloat)SvNV(ST(4));
1515 pv[3] = (GLfloat)SvNV(ST(5));
1516 glConvolutionParameterfv(target,pname,pv);
1517 break;
1518 default:
1519 Perl_croak(aTHX_ "ConvolutionParameter invalid parameter");
1520 break;
1521 }
1522
1523void
1524glHistogram ( target, width, internalFormat, sink )
1525 Uint32 target
1526 Uint32 width
1527 Uint32 internalFormat
1528 GLboolean sink
1529 CODE:
1530 glHistogram(target,width,internalFormat,sink);
1531
1532void
1533glGetHistogram ( target, reset, format, type, values )
1534 Uint32 target
1535 GLboolean reset
1536 Uint32 format
1537 Uint32 type
1538 char *values
1539 CODE:
1540 glGetHistogram(target,reset,format,type,values);
1541
1542void
1543glResetHistogram ( target )
1544 Uint32 target
1545 CODE:
1546 glResetHistogram(target);
1547
1548void
1549glMinmax ( target, internalFormat, sink )
1550 Uint32 target
1551 Uint32 internalFormat
1552 GLboolean sink
1553 CODE:
1554 glMinmax(target,internalFormat,sink);
1555
1556void
1557glGetMinmax ( target, reset, format, type, values )
1558 Uint32 target
1559 GLboolean reset
1560 Uint32 format
1561 Uint32 type
1562 char *values
1563 CODE:
1564 glGetMinmax(target,reset,format,type,values);
1565
1566void
1567glResetMinmax ( target )
1568 Uint32 target
1569 CODE:
1570 glResetMinmax(target);
1571
1572void
1573glBlendEquation ( mode )
1574 Uint32 mode
1575 CODE:
1576 glBlendEquation(mode);
1577
1578#endif // GL_VERSION_1_3
1579
1580void
1581glTexImage2D ( target, level, internalFormat, width, height, border, format, type, data )
1582 GLenum target
1583 Sint32 level
1584 Sint32 internalFormat
1585 Uint32 width
1586 Uint32 height
1587 Sint32 border
1588 GLenum format
1589 GLenum type
1590 char *data
1591 CODE:
1592 glTexImage2D(target,level,internalFormat,width,height,border,format,type,data);
1593
1594void
1595glCopyTexImage2D ( target, level, internalFormat, x, y, width, height, border )
1596 GLenum target
1597 Sint32 level
1598 Sint32 internalFormat
1599 Sint32 x
1600 Sint32 y
1601 Uint32 width
1602 Uint32 height
1603 Sint32 border
1604 CODE:
1605 glCopyTexImage2D(target,level,internalFormat,x,y,width,height,border);
1606
1607void
1608glTexSubImage2D ( target, level, xoffset, yoffset, width, height, format, type, data )
1609 GLenum target
1610 Sint32 level
1611 Sint32 xoffset
1612 Sint32 yoffset
1613 Uint32 width
1614 Uint32 height
1615 GLenum format
1616 GLenum type
1617 char *data
1618 CODE:
1619 glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,data);
1620
1621void
1622glCopyTexSubImage2D ( target, level, xoffset, yoffset, x, y, width, height )
1623 GLenum target
1624 Sint32 level
1625 Sint32 xoffset
1626 Sint32 yoffset
1627 Sint32 x
1628 Sint32 y
1629 Uint32 width
1630 Uint32 height
1631 CODE:
1632 glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
1633
1634void
1635glTexImage1D ( target, level, internalFormat, width, border, format, type, data )
1636 GLenum target
1637 Sint32 level
1638 Sint32 internalFormat
1639 Uint32 width
1640 Sint32 border
1641 GLenum format
1642 GLenum type
1643 char *data
1644 CODE:
1645 glTexImage1D(target,level,internalFormat,width,border,format,type,data);
1646
1647void
1648glTexSubImage1D ( target, level, xoffset, width, format, type, data )
1649 GLenum target
1650 Sint32 level
1651 Sint32 xoffset
1652 Uint32 width
1653 GLenum format
1654 GLenum type
1655 char *data
1656 CODE:
1657 glTexSubImage1D(target,level,xoffset,width,format,type,data);
1658
1659void
1660glCopyTexImage1D ( target, level, internalFormat, x, y, width, border )
1661 GLenum target
1662 Sint32 level
1663 Sint32 internalFormat
1664 Sint32 x
1665 Sint32 y
1666 Uint32 width
1667 Sint32 border
1668 CODE:
1669 glCopyTexImage1D(target,level,internalFormat,x,y,width,border);
1670
1671void
1672glCopyTexSubImage1D ( target, level, xoffset, x, y, width )
1673 GLenum target
1674 Sint32 level
1675 Sint32 xoffset
1676 Sint32 x
1677 Sint32 y
1678 Uint32 width
1679 CODE:
1680 glCopyTexSubImage1D(target,level,xoffset,x,y,width);
1681
1682#ifdef GL_VERSION_1_3
1683
1684void
1685glTexImage3D ( target, level, internalFormat, width, height, depth, border, format, type, data )
1686 GLenum target
1687 Sint32 level
1688 Sint32 internalFormat
1689 Uint32 width
1690 Uint32 height
1691 Uint32 depth
1692 Sint32 border
1693 GLenum format
1694 GLenum type
1695 char *data
1696 CODE:
1697 glTexImage3D(target,level,internalFormat,width,height,depth,border,format,type,data);
1698
1699void
1700glTexSubImage3D ( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data )
1701 GLenum target
1702 Sint32 level
1703 Sint32 xoffset
1704 Sint32 yoffset
1705 Sint32 zoffset
1706 Uint32 width
1707 Uint32 height
1708 Uint32 depth
1709 GLenum format
1710 GLenum type
1711 char *data
1712 CODE:
1713 glTexSubImage3D(target,level,xoffset,yoffset,zoffset,
1714 width,height,depth,format,type,data);
1715
1716void
1717glCopyTexSubImage3D ( target, level, xoffset, yoffset, zoffset, x, y, width, height )
1718 GLenum target
1719 Sint32 level
1720 Sint32 xoffset
1721 Sint32 yoffset
1722 Sint32 zoffset
1723 Sint32 x
1724 Sint32 y
1725 Uint32 width
1726 Uint32 height
1727 CODE:
1728 glCopyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height);
1729
1730#endif // GL_VERSION_1_3
1731
1732AV*
1733glGenTextures ( n )
1734 Uint32 n;
1735 CODE:
1736 Uint32 i;
1737 Uint32 *names;
1738 names = (Uint32*)safemalloc(sizeof(Uint32)*n);
1739 RETVAL = newAV();
1740 glGenTextures(n,names);
1741 for ( i = 0; i < n; i++ ) {
1742 av_push(RETVAL,newSViv(names[i]));
1743 }
1744 safefree(names);
1745 OUTPUT:
1746 RETVAL
1747
1748GLboolean
1749glIsTexture ( texture )
1750 Uint32 texture
1751 CODE:
1752 RETVAL = glIsTexture(texture);
1753 OUTPUT:
1754 RETVAL
1755
1756void
1757glBindTexture ( target, texture )
1758 GLenum target
1759 Uint32 texture
1760 CODE:
1761 glBindTexture(target,texture);
1762
1763void
1764glDeleteTextures ( ... )
1765 CODE:
1766 Uint32 *textures;
1767 int i;
1768 textures = (Uint32*)safemalloc(sizeof(Uint32) * items);
1769 if ( textures ) {
1770 for ( i = 0; i < items; i++ ) {
1771 textures[i] = SvIV(ST(i));
1772 }
1773 }
1774 glDeleteTextures(items,textures);
1775 safefree(textures);
1776
1777AV*
1778glAreTexturesResident ( ... )
1779 CODE:
1780 Uint32 *textures;
1781 GLboolean *homes;
1782 int i;
1783 RETVAL = newAV();
1784 textures = (Uint32*)safemalloc(sizeof(Uint32) * items);
1785 homes = (GLboolean*)safemalloc(sizeof(GLboolean) * items);
1786 if ( textures ) {
1787 for ( i = 0; i < items; i++ ) {
1788 textures[i] = SvIV(ST(i));
1789 }
1790 }
1791 if ( GL_FALSE != glAreTexturesResident(items,textures,homes)) {
1792 for (i = 0; i < items; i++ ) {
1793 av_push(RETVAL,newSViv(homes[i]));
1794 }
1795 }
1796 safefree(homes);
1797 safefree(textures);
1798 OUTPUT:
1799 RETVAL
1800
1801void
1802glPrioritizeTextures ( n, names, priorities )
1803 Uint32 n
1804 char *names
1805 char *priorities
1806 CODE:
1807 glPrioritizeTextures(n,(GLuint*)names,(const GLclampf *)priorities);
1808
1809void
1810glTexEnv ( target, name, ... )
1811 GLenum target
1812 GLenum name
1813 CODE:
1814 float pv[4];
1815 GLint p;
1816 switch(name) {
1817 case GL_TEXTURE_ENV_MODE:
1818 p = SvIV(ST(2));
1819 glTexEnvi(target,name,p);
1820 break;
1821 case GL_TEXTURE_ENV_COLOR:
1822 pv[0] = SvNV(ST(2));
1823 pv[1] = SvNV(ST(3));
1824 pv[2] = SvNV(ST(4));
1825 pv[3] = SvNV(ST(5));
1826 glTexEnvfv(target,name,pv);
1827 break;
1828 }
1829
1830void
1831glTexCoord ( ... )
1832 CODE:
1833 double s,t,r,q;
1834 if ( items < 1 || items > 4 )
1835 Perl_croak (aTHX_ "usage: SDL::OpenGL::TexCoord(s,[t,[r,[q]]])");
1836 s = t = r = 0.0;
1837 q = 1.0;
1838 switch(items) {
1839 case 4:
1840 q = SvNV(ST(3));
1841 case 3:
1842 r = SvNV(ST(2));
1843 case 2:
1844 t = SvNV(ST(1));
1845 case 1:
1846 s = SvNV(ST(0));
1847 }
1848 glTexCoord4d(s,t,r,q);
1849
1850void
1851glTexParameter ( target, name, ... )
1852 GLenum target
1853 GLenum name
1854 CODE:
1855 GLfloat pv[4];
1856 GLint p;
1857 switch (name) {
1858 case GL_TEXTURE_BORDER_COLOR:
1859 pv[0] = SvNV(ST(2));
1860 pv[1] = SvNV(ST(3));
1861 pv[2] = SvNV(ST(4));
1862 pv[3] = SvNV(ST(5));
1863 glTexParameterfv(target,name,pv);
1864 break;
1865 case GL_TEXTURE_PRIORITY:
1866 case GL_TEXTURE_MIN_LOD:
1867 case GL_TEXTURE_MAX_LOD:
1868 pv[0] = SvNV(ST(2));
1869 glTexParameterf(target,name,pv[0]);
1870 break;
1871 case GL_TEXTURE_BASE_LEVEL:
1872 case GL_TEXTURE_MAX_LEVEL:
1873 default:
1874 p = SvIV(ST(2));
1875 glTexParameteri(target,name,p);
1876 break;
1877 }
1878
1879void
1880glTexGen ( coord, name, ... )
1881 GLenum coord
1882 GLenum name
1883 CODE:
1884 GLdouble *pv;
1885 GLint p;
1886 int i;
1887 switch (name) {
1888 case GL_TEXTURE_GEN_MODE:
1889 p = SvIV(ST(2));
1890 glTexGeni(coord,name,p);
1891 break;
1892 default:
1893 if ( items == 2 )
1894 Perl_croak(aTHX_ "usage: glTexGen(coord,name,...)");
1895 pv = (GLdouble*)safemalloc(sizeof(GLdouble)*(items-2));
1896 for ( i = 0; i < items - 2; i++ ) {
1897 pv[i] = SvNV(ST(i+2));
1898 }
1899 glTexGendv(coord,name,pv);
1900 safefree(pv);
1901 break;
1902 }
1903
1904#ifdef GL_VERSION_1_3
1905
1906void
1907glActiveTextureARB ( texUnit )
1908 GLenum texUnit
1909 CODE:
1910 glActiveTextureARB(texUnit);
1911
1912void
1913glMultiTexCoord ( texUnit, ... )
1914 Uint32 texUnit
1915 CODE:
1916 double s,t,r,q;
1917 if ( items < 2 || items > 5 )
1918 Perl_croak (aTHX_ "usage: SDL::OpenGL::MultiTexCoord(tex,s,[t,[r,[q]]])");
1919 s = t = r = 0.0;
1920 q = 1.0;
1921 switch(items) {
1922 case 5:
1923 q = SvNV(ST(3));
1924 case 4:
1925 r = SvNV(ST(2));
1926 case 3:
1927 t = SvNV(ST(1));
1928 case 2:
1929 s = SvNV(ST(0));
1930 }
1931 glMultiTexCoord4dARB(texUnit,s,t,r,q);
1932
1933#endif // GL_VERSION_1_3
1934
1935void
1936glDrawBuffer ( mode )
1937 GLenum mode
1938 CODE:
1939 glDrawBuffer(mode);
1940
1941void
1942glReadBuffer ( mode )
1943 GLenum mode
1944 CODE:
1945 glReadBuffer(mode);
1946
1947void
1948glIndexMask ( mask )
1949 Uint32 mask
1950 CODE:
1951 glIndexMask(mask);
1952
1953void
1954glColorMask ( red, green, blue, alpha )
1955 GLboolean red
1956 GLboolean green
1957 GLboolean blue
1958 GLboolean alpha
1959 CODE:
1960 glColorMask(red,green,blue,alpha);
1961
1962void
1963glDepthMask ( flag )
1964 GLboolean flag
1965 CODE:
1966 glDepthMask(flag);
1967
1968void
1969glStencilMask ( mask )
1970 Uint32 mask
1971 CODE:
1972 glStencilMask(mask);
1973
1974void
1975glScissor ( x , y, width, height )
1976 Sint32 x
1977 Sint32 y
1978 Uint32 width
1979 Uint32 height
1980 CODE:
1981 glScissor(x,y,width,height);
1982
1983void
1984glAlphaFunc ( func, ref )
1985 GLenum func
1986 double ref
1987 CODE:
1988 glAlphaFunc(func,ref);
1989
1990void
1991glStencilFunc ( func, ref, mask )
1992 GLenum func
1993 Sint32 ref
1994 Uint32 mask
1995 CODE:
1996 glStencilFunc(func,ref,mask);
1997
1998void
1999glStencilOp ( fail, zfail, zpass )
2000 GLenum fail
2001 GLenum zfail
2002 GLenum zpass
2003 CODE:
2004 glStencilOp(fail,zfail,zpass);
2005
2006void
2007glDepthFunc ( func )
2008 GLenum func
2009 CODE:
2010 glDepthFunc(func);
2011
2012void
2013glLogicOp ( opcode )
2014 GLenum opcode
2015 CODE:
2016 glLogicOp(opcode);
2017
2018void
2019glAccum ( op, value )
2020 GLenum op
2021 double value
2022 CODE:
2023 glAccum(op,value);
2024
2025void
2026glMap1 ( target, u1, u2, stride, order, points )
2027 GLenum target
2028 double u1
2029 double u2
2030 Sint32 stride
2031 Sint32 order
2032 char *points
2033 CODE:
2034 glMap1d(target,u1,u2,stride,order,(double*)points);
2035
2036void
2037glEvalCoord1 ( u )
2038 double u
2039 CODE:
2040 glEvalCoord1d(u);
2041
2042void
2043glMapGrid1 ( n, u1, u2 )
2044 Sint32 n
2045 double u1
2046 double u2
2047 CODE:
2048 glMapGrid1d(n,u1,u2);
2049
2050void
2051glEvalMesh1 ( mode, p1, p2 )
2052 GLenum mode
2053 Sint32 p1
2054 Sint32 p2
2055 CODE:
2056 glEvalMesh1(mode,p1,p2);
2057
2058void
2059glMap2 ( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points )
2060 GLenum target
2061 double u1
2062 double u2
2063 Sint32 ustride
2064 Sint32 uorder
2065 double v1
2066 double v2
2067 Sint32 vstride
2068 Sint32 vorder
2069 char *points
2070 CODE:
2071 glMap2d(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,(double*)points);
2072
2073void
2074glEvalCoord2 ( u, v )
2075 double u
2076 double v
2077 CODE:
2078 glEvalCoord2d(u,v);
2079
2080void
2081glMapGrid2 ( nu, u1, u2, nv, v1, v2 )
2082 Sint32 nu
2083 double u1
2084 double u2
2085 Sint32 nv
2086 double v1
2087 double v2
2088 CODE:
2089 glMapGrid2d(nu,u1,u2,nv,v1,v2);
2090
2091void
2092glEvalMesh2 ( mode, i1, i2, j1, j2 )
2093 GLenum mode
2094 Sint32 i1
2095 Sint32 i2
2096 Sint32 j1
2097 Sint32 j2
2098 CODE:
2099 glEvalMesh2(mode,i1,i2,j1,j2);
2100
2101GLenum
2102glGetError ( )
2103 CODE:
2104 RETVAL = glGetError();
2105 OUTPUT:
2106 RETVAL
2107
2108GLint
2109glRenderMode ( mode )
2110 GLenum mode
2111 CODE:
2112 RETVAL = glRenderMode( mode );
2113 OUTPUT:
2114 RETVAL
2115
2116void
2117glInitNames ( )
2118 CODE:
2119 glInitNames();
2120
2121void
2122glPushName ( name )
2123 GLuint name
2124 CODE:
2125 glPushName(name);
2126
2127void
2128glPopName ( )
2129 CODE:
2130 glPopName();
2131
2132void
2133glLoadName ( name )
2134 GLuint name
2135 CODE:
2136 glLoadName(name);
2137
2138void
2139glFeedbackBuffer ( size, type, buffer )
2140 GLuint size
2141 GLenum type
2142 float* buffer
2143 CODE:
2144 glFeedbackBuffer(size,type,buffer);
2145
2146void
2147glPassThrough ( token )
2148 GLfloat token
2149 CODE:
2150 glPassThrough(token);
2151
2152
2153#endif
2154
2155#ifdef HAVE_GLU
2156
2157void
2158gluLookAt ( eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz )
2159 double eyex
2160 double eyey
2161 double eyez
2162 double centerx
2163 double centery
2164 double centerz
2165 double upx
2166 double upy
2167 double upz
2168 CODE:
2169 gluLookAt(eyex,eyey,eyez,centerx,centery,centerz,upx,upy,upz);
2170
2171void
2172gluPerspective ( fovy, aspect, n, f )
2173 double fovy
2174 double aspect
2175 double n
2176 double f
2177 CODE:
2178 gluPerspective(fovy,aspect,n,f);
2179
2180void
2181gluPickMatrix ( x, y, delx, dely, viewport )
2182 double x
2183 double y
2184 double delx
2185 double dely
2186 GLint* viewport
2187 CODE:
2188 gluPickMatrix(x,y,delx,dely,viewport);
2189
2190void
2191gluOrtho2D ( left, right, bottom, top )
2192 double left
2193 double right
2194 double bottom
2195 double top
2196 CODE:
2197 gluOrtho2D(left,right,bottom,top);
2198
2199int
2200gluScaleImage ( format, widthin, heightin, typein, datain, widthout, heightout, typeout, dataout )
2201 GLenum format
2202 Uint32 widthin
2203 Uint32 heightin
2204 GLenum typein
2205 char *datain
2206 Uint32 widthout
2207 Uint32 heightout
2208 GLenum typeout
2209 char *dataout
2210 CODE:
2211 RETVAL = gluScaleImage(format,widthin,heightin,typein,datain,
2212 widthout,heightout,typeout,dataout);
2213 OUTPUT:
2214 RETVAL
2215
2216int
2217gluBuild1DMipmaps ( target, internalFormat, width, format, type, data )
2218 GLenum target
2219 Sint32 internalFormat
2220 Uint32 width
2221 GLenum format
2222 GLenum type
2223 char *data
2224 CODE:
2225 RETVAL = gluBuild1DMipmaps(target,internalFormat,width,format,type,data);
2226 OUTPUT:
2227 RETVAL
2228
2229int
2230gluBuild2DMipmaps ( target, internalFormat, width, height, format, type, data )
2231 GLenum target
2232 Sint32 internalFormat
2233 Uint32 width
2234 Uint32 height
2235 GLenum format
2236 GLenum type
2237 char *data
2238 CODE:
2239 RETVAL = gluBuild2DMipmaps(target,internalFormat,width,height,format,type,data);
2240 OUTPUT:
2241 RETVAL
2242
2243
2244#if HAVE_GLU_VERSION >= 12
2245int
2246gluBuild3DMipmaps ( target, internalFormat, width, height, depth, format, type, data )
2247 GLenum target
2248 Sint32 internalFormat
2249 Uint32 width
2250 Uint32 height
2251 Uint32 depth
2252 GLenum format
2253 GLenum type
2254 char *data
2255 CODE:
2256 RETVAL = gluBuild3DMipmaps(target,internalFormat,width,height,depth,
2257 format,type,data);
2258 OUTPUT:
2259 RETVAL
2260
2261#else
2262void
2263gluBuild3DMipmaps ( )
2264 CODE:
2265 Perl_croak (aTHX_ "SDL::OpenGL::Build3DMipmaps requires GLU 1.2");
2266
2267#endif
2268
2269#if HAVE_GLU_VERSION >= 12
2270int
2271gluBuild1DMipmapLevels ( target, internalFormat, width, format, type, level, base, max, data )
2272 GLenum target
2273 Sint32 internalFormat
2274 Uint32 width
2275 GLenum format
2276 GLenum type
2277 Sint32 level
2278 Sint32 base
2279 Sint32 max
2280 char *data
2281 CODE:
2282 RETVAL = gluBuild1DMipmapLevels(target,internalFormat,width,
2283 format,type,level,base,max,data);
2284 OUTPUT:
2285 RETVAL
2286
2287#else
2288void
2289gluBuild1DMipmapLevels ()
2290 CODE:
2291 Perl_croak(aTHX_ "SDL::OpenGL::Build1DMipmapLevels requires GLU 1.2");
2292
2293#endif
2294
2295#if HAVE_GLU_VERSION >= 12
2296int
2297gluBuild2DMipmapLevels ( target, internalFormat, width, height, format, type, level, base, max, data )
2298 GLenum target
2299 Sint32 internalFormat
2300 Uint32 width
2301 Uint32 height
2302 GLenum format
2303 GLenum type
2304 Sint32 level
2305 Sint32 base
2306 Sint32 max
2307 char *data
2308 CODE:
2309 RETVAL = gluBuild2DMipmapLevels(target,internalFormat,width,height,
2310 format,type,level,base,max,data);
2311 OUTPUT:
2312 RETVAL
2313
2314#else
2315void
2316gluBuild2DMipmapLevels ()
2317 CODE:
2318 Perl_croak(aTHX_ "SDL::OpenGL::Build2DMipmapLevels requires GLU 1.2");
2319
2320#endif
2321
2322#if HAVE_GLU_VERSION >= 12
2323int
2324gluBuild3DMipmapLevels ( target, internalFormat, width, height, depth, format, type, level, base, max, data )
2325 GLenum target
2326 Sint32 internalFormat
2327 Uint32 width
2328 Uint32 height
2329 Uint32 depth
2330 GLenum format
2331 GLenum type
2332 Sint32 level
2333 Sint32 base
2334 Sint32 max
2335 char *data
2336 CODE:
2337 RETVAL = gluBuild3DMipmapLevels(target,internalFormat,width,height,depth,
2338 format,type,level,base,max,data);
2339 OUTPUT:
2340 RETVAL
2341
2342#else
2343void
2344gluBuild3DMipmapLevels ()
2345 CODE:
2346 Perl_croak(aTHX_ "SDL::OpenGL::Build3DMipmapLevels requires GLU 1.2");
2347
2348#endif
2349
2350char*
2351gluErrorString ( code )
2352 GLenum code
2353 CODE:
2354 RETVAL = (char*)gluErrorString(code);
2355 OUTPUT:
2356 RETVAL
2357
2358GLUnurbsObj*
2359gluNewNurbsRenderer ()
2360 CODE:
2361 RETVAL = gluNewNurbsRenderer();
2362 OUTPUT:
2363 RETVAL
2364
2365void
2366gluDeleteNurbsRenderer ( obj )
2367 GLUnurbsObj *obj
2368 CODE:
2369 gluDeleteNurbsRenderer(obj);
2370
2371void
2372gluNurbsProperty ( obj, property, value )
2373 GLUnurbsObj *obj
2374 GLenum property
2375 double value
2376 CODE:
2377 gluNurbsProperty(obj,property,(float)value);
2378
2379void
2380gluLoadSamplingMatrices ( obj, mm, pm, vp )
2381 GLUnurbsObj *obj
2382 char *mm
2383 char *pm
2384 char *vp
2385 CODE:
2386 gluLoadSamplingMatrices(obj,(GLfloat*)mm,(GLfloat*)pm,(GLint*)vp);
2387
2388double
2389gluGetNurbsProperty ( obj, property )
2390 GLUnurbsObj *obj
2391 GLenum property
2392 CODE:
2393 float f;
2394 gluGetNurbsProperty(obj,property,&f);
2395 RETVAL = (double)f;
2396 OUTPUT:
2397 RETVAL
2398
2399void
2400gluNurbsCallback ( obj, which, cb )
2401 GLUnurbsObj *obj
2402 GLenum which
2403 SV *cb
2404 CODE:
2405 switch(which) {
2406 case GLU_ERROR:
2407 sdl_perl_nurbs_error_hook = cb;
2408 gluNurbsCallback(obj,GLU_ERROR,(GLvoid*)sdl_perl_nurbs_error_callback);
2409 break;
2410#ifdef GLU_NURBS_BEGIN
2411 case GLU_NURBS_BEGIN:
2412 case GLU_NURBS_BEGIN_DATA:
2413 gluNurbsCallbackData(obj,(void*)cb);
2414 gluNurbsCallback(obj,GLU_NURBS_BEGIN_DATA,
2415 (GLvoid*)sdl_perl_nurbs_being_callback);
2416 break;
2417 case GLU_NURBS_TEXTURE_COORD:
2418 case GLU_NURBS_TEXTURE_COORD_DATA:
2419 gluNurbsCallbackData(obj,(void*)cb);
2420 gluNurbsCallback(obj,GLU_NURBS_TEXTURE_COORD_DATA,
2421 (GLvoid*)sdl_perl_nurbs_multi_callback);
2422 break;
2423 case GLU_NURBS_COLOR:
2424 case GLU_NURBS_COLOR_DATA:
2425 gluNurbsCallbackData(obj,(void*)cb);
2426 gluNurbsCallback(obj,GLU_NURBS_COLOR_DATA,
2427 (GLvoid*)sdl_perl_nurbs_multi_callback);
2428 break;
2429 case GLU_NURBS_NORMAL:
2430 case GLU_NURBS_NORMAL_DATA:
2431 gluNurbsCallbackData(obj,(void*)cb);
2432 gluNurbsCallback(obj,GLU_NURBS_NORMAL_DATA,
2433 (GLvoid*)sdl_perl_nurbs_multi_callback);
2434 break;
2435 case GLU_NURBS_VERTEX:
2436 case GLU_NURBS_VERTEX_DATA:
2437 gluNurbsCallbackData(obj,(void*)cb);
2438 gluNurbsCallback(obj,GLU_NURBS_VERTEX_DATA,
2439 (GLvoid*)sdl_perl_nurbs_multi_callback);
2440 break;
2441 case GLU_NURBS_END:
2442 case GLU_NURBS_END_DATA:
2443 gluNurbsCallbackData(obj,(void*)cb);
2444 gluNurbsCallback(obj,GLU_NURBS_END_DATA,
2445 (GLvoid*)sdl_perl_nurbs_end_callback);
2446 break;
2447#endif
2448 default:
2449 Perl_croak(aTHX_ "SDL::OpenGL::NurbsCallback - invalid type");
2450 }
2451
2452void
2453gluNurbsCallbackData ( obj, cb )
2454 GLUnurbsObj *obj
2455 SV *cb
2456 CODE:
2457 gluNurbsCallbackData(obj,(void*)cb);
2458
2459void
2460gluBeginSurface ( obj )
2461 GLUnurbsObj *obj
2462 CODE:
2463 gluBeginSurface(obj);
2464
2465void
2466gluEndSurface ( obj )
2467 GLUnurbsObj *obj
2468 CODE:
2469 gluEndSurface(obj);
2470
2471void
2472gluNurbsSurface ( obj, uknot_count, uknot, vknot_count, vknot, u_stride, v_stride, ctlarray, uorder, vorder, type )
2473 GLUnurbsObj *obj
2474 Sint32 uknot_count
2475 char *uknot
2476 Sint32 vknot_count
2477 char *vknot
2478 Sint32 u_stride
2479 Sint32 v_stride
2480 char *ctlarray
2481 Sint32 uorder
2482 Sint32 vorder
2483 GLenum type
2484 CODE:
2485 gluNurbsSurface(obj,uknot_count,(GLfloat*)uknot,vknot_count,(GLfloat*)vknot,
2486 u_stride,v_stride,(GLfloat*)ctlarray,uorder,vorder,type);
2487
2488void
2489gluBeginCurve ( obj )
2490 GLUnurbsObj *obj
2491 CODE:
2492 gluBeginCurve(obj);
2493
2494void
2495gluEndCurve ( obj )
2496 GLUnurbsObj *obj
2497 CODE:
2498 gluEndCurve(obj);
2499
2500void
2501gluNurbsCurve ( obj, uknot_count, uknot, u_stride, ctlarray, uorder, type )
2502 GLUnurbsObj *obj
2503 Sint32 uknot_count
2504 char *uknot
2505 Sint32 u_stride
2506 char *ctlarray
2507 Sint32 uorder
2508 GLenum type
2509 CODE:
2510 gluNurbsCurve(obj,uknot_count,(GLfloat*)uknot,u_stride,(GLfloat*)ctlarray,
2511 uorder,type);
2512
2513void
2514gluBeginTrim ( obj )
2515 GLUnurbsObj *obj
2516 CODE:
2517 gluBeginTrim(obj);
2518
2519void
2520gluEndTrim ( obj )
2521 GLUnurbsObj *obj
2522 CODE:
2523 gluEndTrim(obj);
2524
2525void
2526gluPwlCurve ( obj, count, array, stride, type )
2527 GLUnurbsObj *obj
2528 Sint32 count
2529 char *array
2530 Sint32 stride
2531 GLenum type
2532 CODE:
2533 gluPwlCurve(obj,count,(GLfloat*)array,stride,type);
2534
2535AV*
2536gluUnProject ( winx, winy, winz, mm, pm, vp )
2537 double winx
2538 double winy
2539 double winz
2540 char *mm
2541 char *pm
2542 char *vp
2543 CODE:
2544 GLdouble objx, objy, objz;
2545 RETVAL = newAV();
2546 av_push(RETVAL,newSViv(gluUnProject(winx,winy,winz,(GLdouble*)mm,
2547 (GLdouble*)pm,(GLint*)vp,&objx,&objy,&objz)));
2548 av_push(RETVAL,newSVnv((double)objx));
2549 av_push(RETVAL,newSVnv((double)objy));
2550 av_push(RETVAL,newSVnv((double)objz));
2551 OUTPUT:
2552 RETVAL
2553
2554
2555#ifdef GL_VERSION_1_3
2556
2557AV*
2558gluUnProject4 ( winx, winy, winz, clipw, mm, pm, vp, n, f )
2559 double winx
2560 double winy
2561 double winz
2562 double clipw
2563 char *mm
2564 char *pm
2565 char *vp
2566 double n
2567 double f
2568 CODE:
2569 GLdouble objx, objy, objz, objw;
2570 RETVAL = newAV();
2571 av_push(RETVAL,newSViv(gluUnProject4(winx,winy,winz,clipw,(GLdouble*)mm,
2572 (GLdouble*)pm,(GLint*)vp,(GLclampd)n,(GLclampd)f,
2573 &objx,&objy,&objz,&objw)));
2574 av_push(RETVAL,newSVnv((double)objx));
2575 av_push(RETVAL,newSVnv((double)objy));
2576 av_push(RETVAL,newSVnv((double)objz));
2577 av_push(RETVAL,newSVnv((double)objw));
2578 OUTPUT:
2579 RETVAL
2580
2581#endif // GL_VERSION_1_3
2582
2583AV*
2584gluProject ( objx, objy, objz, mm, pm, vp )
2585 double objx
2586 double objy
2587 double objz
2588 char *mm
2589 char *pm
2590 char *vp
2591 CODE:
2592 GLdouble winx, winy, winz;
2593 RETVAL = newAV();
2594 av_push(RETVAL,newSViv(gluUnProject(objx,objy,objz,(GLdouble*)mm,
2595 (GLdouble*)pm,(GLint*)vp,&winx,&winy,&winz)));
2596 av_push(RETVAL,newSVnv((double)winx));
2597 av_push(RETVAL,newSVnv((double)winy));
2598 av_push(RETVAL,newSVnv((double)winz));
2599 OUTPUT:
2600 RETVAL
2601
2602#ifdef GL_VERSION_1_2
2603
2604GLUtesselator*
2605gluNewTess ()
2606 CODE:
2607 RETVAL = gluNewTess();
2608 OUTPUT:
2609 RETVAL
2610
2611void
2612gluTessCallback ( tess, type )
2613 GLUtesselator *tess
2614 GLenum type
2615 CODE:
2616 switch(type) {
2617 case GLU_TESS_BEGIN:
2618 case GLU_TESS_BEGIN_DATA:
2619 gluTessCallback(tess,GLU_TESS_BEGIN_DATA,
2620 (GLvoid*)sdl_perl_tess_begin_callback);
2621 break;
2622
2623 case GLU_TESS_EDGE_FLAG:
2624 case GLU_TESS_EDGE_FLAG_DATA:
2625 gluTessCallback(tess,GLU_TESS_EDGE_FLAG_DATA,
2626 (GLvoid*)sdl_perl_tess_edge_flag_callback);
2627 break;
2628
2629 case GLU_TESS_VERTEX:
2630 case GLU_TESS_VERTEX_DATA:
2631 gluTessCallback(tess,GLU_TESS_VERTEX_DATA,
2632 (GLvoid*)sdl_perl_tess_vertex_callback);
2633 break;
2634
2635 case GLU_TESS_END:
2636 case GLU_TESS_END_DATA:
2637 gluTessCallback(tess,GLU_TESS_END_DATA,
2638 (GLvoid*)sdl_perl_tess_end_callback);
2639 break;
2640
2641 case GLU_TESS_COMBINE:
2642 case GLU_TESS_COMBINE_DATA:
2643 gluTessCallback(tess,GLU_TESS_COMBINE_DATA,
2644 (GLvoid*)sdl_perl_tess_combine_callback);
2645 break;
2646
2647 case GLU_TESS_ERROR:
2648 case GLU_TESS_ERROR_DATA:
2649 gluTessCallback(tess,GLU_TESS_ERROR_DATA,
2650 (GLvoid*)sdl_perl_tess_error_callback);
2651 break;
2652 }
2653
2654void
2655gluTessProperty ( tessobj, property, value )
2656 GLUtesselator *tessobj
2657 Uint32 property
2658 double value
2659 CODE:
2660 gluTessProperty(tessobj,property,value);
2661
2662double
2663gluGetTessProperty ( tessobj, property )
2664 GLUtesselator *tessobj
2665 Uint32 property
2666 CODE:
2667 gluGetTessProperty(tessobj,property,&RETVAL);
2668 OUTPUT:
2669 RETVAL
2670
2671void
2672gluTessNormal ( tessobj, x, y, z )
2673 GLUtesselator *tessobj
2674 double x
2675 double y
2676 double z
2677 CODE:
2678 gluTessNormal(tessobj,x,y,z);
2679
2680void
2681gluTessBeginPolygon ( tessobj, cb )
2682 GLUtesselator *tessobj
2683 SV *cb
2684 CODE:
2685 gluTessBeginPolygon(tessobj,cb);
2686
2687void
2688gluTessEndPolygon ( tessobj )
2689 GLUtesselator *tessobj
2690 CODE:
2691 gluTessEndPolygon(tessobj);
2692
2693void
2694gluTessBeginContour ( tessobj )
2695 GLUtesselator *tessobj
2696 CODE:
2697 gluTessBeginContour(tessobj);
2698
2699void
2700gluTessEndContour ( tessobj )
2701 GLUtesselator *tessobj
2702 CODE:
2703 gluTessEndContour(tessobj);
2704
2705void
2706gluDeleteTess ( tessobj )
2707 GLUtesselator *tessobj
2708 CODE:
2709 gluDeleteTess(tessobj);
2710
2711void
2712gluTessVertex ( tessobj, coords, vd )
2713 GLUtesselator *tessobj
2714 char *coords
2715 char *vd
2716 CODE:
2717 gluTessVertex(tessobj,(GLdouble*)coords,vd);
2718
5a2c431f 2719#endif
4db254ce 2720
2721GLUquadric *
2722gluNewQuadric ()
2723 CODE:
2724 RETVAL = gluNewQuadric ();
2725 OUTPUT:
2726 RETVAL
2727
2728void
2729gluDeleteQuadric (quad)
2730 GLUquadric *quad
2731 CODE:
2732 gluDeleteQuadric(quad);
2733
2734void
2735gluQuadricNormals ( quad, normal )
2736 GLUquadric *quad
2737 GLenum normal
2738 CODE:
2739 gluQuadricNormals(quad, normal);
2740
2741
2742void
2743gluQuadricTexture ( quad, texture )
2744 GLUquadric *quad
2745 GLboolean texture
2746 CODE:
2747 gluQuadricTexture ( quad, texture );
2748
2749void
2750gluCylinder ( quad, base, top, height, slices, stacks )
2751 GLUquadric *quad
2752 GLdouble base
2753 GLdouble top
2754 GLdouble height
2755 GLint slices
2756 GLint stacks
2757 CODE:
2758 gluCylinder ( quad, base, top, height, slices, stacks );
5a2c431f 2759
4db254ce 2760void
2761gluDisk ( quad, inner, outer, slices, loops )
2762 GLUquadric *quad
2763 GLdouble inner
2764 GLdouble outer
2765 GLint slices
2766 GLint loops
2767 CODE:
2768 gluDisk ( quad, inner, outer, slices, loops );
2769
2770void
2771gluPartialDisk ( quad, inner, outer, slices, loops, start, sweep )
2772 GLUquadric *quad
2773 GLdouble inner
2774 GLdouble outer
2775 GLint slices
2776 GLint loops
2777 GLdouble start
2778 GLdouble sweep
2779
2780 CODE:
2781 gluPartialDisk ( quad, inner, outer, slices, loops, start, sweep );
2782
2783void
2784gluSphere ( quad, radius, slices, stacks )
2785 GLUquadric *quad
2786 GLdouble radius
2787 GLint slices
2788 GLint stacks
2789 CODE:
2790 gluSphere ( quad, radius, slices, stacks );
8fde61e3 2791
5a2c431f 2792
faad43be 2793
2794void
2795glXUseXFont ( font, first, count, list_base )
2796 Font font
2797 int first
2798 int count
2799 int list_base
2800 CODE:
2801 glXUseXFont ( font, first, count, list_base );
2802
8fde61e3 2803#endif
2804
Unnamed repository; edit this file to name it for gitweb.