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