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