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