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