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