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