projects / sdlgit/SDL_perl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | history | HEAD
Added raster subs
[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
4db254ce 711const char * glGetString ( name )
712 GLenum name
713 CODE:
714 RETVAL = (const char *)glGetString (name);
715 OUTPUT:
716 RETVAL
8fde61e3 717
718Uint32
719glIsEnabled ( cap )
720 Uint32 cap
721 CODE:
722 RETVAL = glIsEnabled(cap);
723 OUTPUT:
724 RETVAL
725
726void
727glPointSize ( size )
728 double size
729 CODE:
730 glPointSize((GLfloat)size);
731
732void
733glLineWidth ( size )
734 double size
735 CODE:
736 glLineWidth((GLfloat)size);
737
738void
739glLineStipple ( factor, pattern )
740 Sint32 factor
741 Uint16 pattern
742 CODE:
743 glLineStipple(factor,pattern);
744
745void
746glPolygonMode ( face, mode )
747 GLenum face
748 GLenum mode
749 CODE:
750 glPolygonMode(face,mode);
751
752void
753glFrontFace ( mode )
754 GLenum mode
755 CODE:
756 glFrontFace(mode);
757
758void
759glCullFace ( mode )
760 GLenum mode
761 CODE:
762 glCullFace(mode);
763
764void
765glPolygonStipple ( mask )
766 char *mask
767 CODE:
768 glPolygonStipple(mask);
769
770void
771glEdgeFlag ( flag )
772 GLenum flag
773 CODE:
774 glEdgeFlag(flag);
775
776void
777glNormal ( x, y, z )
778 double x
779 double y
780 double z
781 CODE:
782 glNormal3d(x,y,z);
783
784void
785glEnableClientState ( array )
786 GLenum array
787 CODE:
788 glEnableClientState(array);
789
790void
791glDisableClientState ( array )
792 GLenum array
793 CODE:
794 glDisableClientState(array);
795
796void
797glVertexPointer ( size, type, stride, pointer)
798 int size
799 GLenum type
800 Uint32 stride
801 char *pointer
802 CODE:
803 glVertexPointer(size,type,stride,pointer);
804
805void
806glColorPointer ( size, type, stride, pointer )
807 Sint32 size
808 GLenum type
809 Uint32 stride
810 char *pointer
811 CODE:
812 glColorPointer(size,type,stride,pointer);
813
814void
815glNormalPointer ( type, stride, pointer )
816 GLenum type
817 Uint32 stride
818 char *pointer
819 CODE:
820 glNormalPointer(type,stride,pointer);
821
822void
823glTexCoordPointer ( size, type, stride, pointer )
824 Sint32 size
825 GLenum type
826 Uint32 stride
827 char *pointer
828 CODE:
829 glTexCoordPointer(size,type,stride,pointer);
830
831void
832glEdgeFlagPointer ( stride, pointer )
833 Uint32 stride
834 char *pointer
835 CODE:
836 glEdgeFlagPointer(stride,pointer);
837
838void
839glArrayElement ( ith )
840 Uint32 ith
841 CODE:
842 glArrayElement(ith);
843
844void
845glDrawElements ( mode, count, type, indices )
846 GLenum mode
847 Uint32 count
848 GLenum type
849 char *indices
850 CODE:
851 glDrawElements( mode, count, type, indices);
852
853void
854glDrawRangeElements ( mode, start, end, count, type, indices )
855 GLenum mode
856 Uint32 start
857 Uint32 end
858 Uint32 count
859 GLenum type
860 char *indices
861 CODE:
862 glDrawRangeElements(mode,start,end,count,type,indices);
863
864void
865glDrawArrays ( mode, first, count )
866 GLenum mode
867 Uint32 first
868 Uint32 count
869 CODE:
870 glDrawArrays(mode,first,count);
871
872void
873glInterleavedArrays ( format, stride, pointer )
874 GLenum format
875 Uint32 stride
876 char *pointer
877 CODE:
878 glInterleavedArrays(format,stride,pointer);
879
880void
881glPushAttrib ( mask )
882 GLbitfield mask
883 CODE:
884 glPushAttrib(mask);
885
886void
887glPopAttrib ()
888 CODE:
889 glPopAttrib();
890
891void
892glPushClientAttrib ( mask )
893 GLbitfield mask
894 CODE:
895 glPushClientAttrib(mask);
896
897void
898glPopClientAttrib ()
899 CODE:
900 glPopClientAttrib();
901
902void
903glMatrixMode ( mode )
904 GLenum mode
905 CODE:
906 glMatrixMode(mode);
907
908void
909glLoadIdentity ()
910 CODE:
911 glLoadIdentity();
912
913void
914glLoadMatrix ( ... )
915 CODE:
916 int i;
917 double mat[16];
918 for ( i = 0; i < 16; i++ ) {
919 mat[i] = (i < items && SvNOK(ST(i)) ? SvNV(ST(i)) : 0.0 );
920 }
921 glLoadMatrixd(mat);
922
923void
924glMultMatrix ( ... )
925 CODE:
926 int i;
927 double mat[16];
928 for ( i = 0; i < 16; i++ ) {
929 mat[i] = (i < items && SvNOK(ST(i)) ? SvNV(ST(i)) : 0.0 );
930 }
931 glMultMatrixd(mat);
932
933void
934glTranslate ( x, y, z )
935 double x
936 double y
937 double z
938 CODE:
939 glTranslated(x,y,z);
940
941void
942glRotate ( angle, x, y, z )
943 double angle
944 double x
945 double y
946 double z
947 CODE:
948 glRotated(angle,x,y,z);
949
950void
951glScale ( x, y, z )
952 double x
953 double y
954 double z
955 CODE:
956 glScaled(x,y,z);
957
958void
959glFrustum ( left, right, bottom, top, n, f )
960 double left
961 double right
962 double bottom
963 double top
964 double n
965 double f
966 CODE:
967 glFrustum(left,right,bottom,top,n,f);
968
969void
970glOrtho ( left, right, bottom, top, n, f )
971 double left
972 double right
973 double bottom
974 double top
975 double n
976 double f
977 CODE:
978 glOrtho(left,right,bottom,top,n,f);
979
980void
981glViewport ( x, y, width, height )
982 Sint32 x
983 Sint32 y
984 Uint32 width
985 Uint32 height
986 CODE:
987 glViewport(x,y,width,height);
988
989void
990glDepthRange ( n, f )
991 double n
992 double f
993 CODE:
994 glDepthRange(n,f);
995
996void
997glPushMatrix ()
998 CODE:
999 glPushMatrix();
1000
1001void
1002glPopMatrix ()
1003 CODE:
1004 glPopMatrix();
1005
1006void
1007glClipPlane ( plane, ... )
1008 GLenum plane
1009 CODE:
1010 double v[4];
1011 int i;
1012 for (i = 0; i < 4; i++ ) {
1013 v[i] = (i+1 < items && SvNOK(ST(i+1))) ? SvNV(ST(i+1)) : 0.0;
1014 }
1015 glClipPlane(plane,v);
1016
1017void
1018glColor ( r, g, b, ... )
1019 double r
1020 double g
1021 double b
1022 CODE:
1023 if ( items == 4 ) {
1024 double a;
1025 a = SvNV(ST(3));
1026 glColor4d(r,g,b,a);
1027 } else {
1028 glColor3d(r,g,b);
1029 }
1030
1031void
1032glIndex ( c )
1033 Uint32 c
1034 CODE:
1035 glIndexi(c);
1036
1037void
1038glShadeModel ( mode )
1039 GLenum mode
1040 CODE:
1041 glShadeModel(mode);
1042
1043void
1044glLight ( light, name, ... )
1045 GLenum light
1046 GLenum name
1047 CODE:
1048 int i;
1049 if ( items == 6 ) {
1050 float v[4];
1051 for ( i = 0; i < 4; i++ ) {
1052 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1053 }
1054 glLightfv(light,name,v);
1055 } else if ( items == 5 ) {
1056 float v[3];
1057 for ( i = 0; i < 3; i++ ) {
1058 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1059 }
1060 glLightfv(light,name,v);
1061 } else if ( items == 3 ) {
1062 float v;
1063 v = SvNV(ST(2));
1064 glLightf(light,name,v);
1065 } else {
1066 Perl_croak(aTHX_ "SDL::OpenGL::Light invalid arguments");
1067 }
1068
1069void
1070glLightModel ( pname, ... )
1071 GLenum pname
1072 CODE:
1073 GLfloat vec[4];
1074 if ( pname == GL_LIGHT_MODEL_LOCAL_VIEWER ||
1075 pname == GL_LIGHT_MODEL_TWO_SIDE ||
1076 pname == GL_LIGHT_MODEL_COLOR_CONTROL ) {
1077 glLightModelf(pname,SvNV(ST(1)));
1078 } else if ( pname == GL_LIGHT_MODEL_AMBIENT) {
1079 vec[0] = SvNV(ST(1));
1080 vec[1] = SvNV(ST(2));
1081 vec[2] = SvNV(ST(3));
1082 vec[3] = SvNV(ST(4));
1083 glLightModelfv(pname,vec);
1084 } else {
1085 Perl_croak(aTHX_ "SDL::OpenGL::glLightModel unknown model %d",pname);
1086 }
1087
1088void
1089glMaterial ( face, name, ... )
1090 GLenum face
1091 GLenum name
1092 CODE:
1093 int i;
1094 if ( items == 6 ) {
1095 float v[4];
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 == 5 ) {
1101 float v[3];
1102 for ( i = 0; i < 4; i++ ) {
1103 v[i] = (SvNOK(ST(i+2))) ? SvNV(ST(i+2)) : 0.0;
1104 }
1105 glMaterialfv(face,name,v);
1106 } else if ( items == 3 ) {
1107 float v;
1108 v = SvNV(ST(2));
1109 glMaterialf(face,name,v);
1110 } else {
1111 Perl_croak(aTHX_ "SDL::OpenGL::Material invalid arguments");
1112 }
1113
1114void
1115glColorMaterial ( face, mode )
1116 GLenum face
1117 GLenum mode
1118 CODE:
1119 glColorMaterial(face,mode);
1120
1121void
1122glBlendFunc ( sfactor, dfactor )
1123 GLenum sfactor
1124 GLenum dfactor
1125 CODE:
1126 glBlendFunc(sfactor,dfactor);
1127
1128
1129void
1130glHint ( target, hint )
1131 GLenum target
1132 GLenum hint
1133 CODE:
1134 glHint(target,hint);
1135
1136void
1137glFog ( name, ... )
1138 GLenum name
1139 CODE:
1140 if ( items == 5 ) {
1141 float v[4];
1142 v[0] = SvNV(ST(1));
1143 v[1] = SvNV(ST(2));
1144 v[2] = SvNV(ST(3));
1145 v[3] = SvNV(ST(4));
1146 glFogfv(name,v);
1147 } else if ( items == 2 ) {
1148 float v;
1149 v = SvNV(ST(1));
1150 glFogf(name,v);
1151 } else {
1152 Perl_croak(aTHX_ "SDL::OpenGL::Material invalid arguments");
1153 }
1154
1155void
1156glPolygonOffset ( factor, units )
1157 double factor
1158 double units
1159 CODE:
1160 glPolygonOffset(factor,units);
1161
1162Uint32
1163glGenLists ( range )
1164 Uint32 range
1165 CODE:
1166 RETVAL = glGenLists(range);
1167 OUTPUT:
1168 RETVAL
1169
1170void
1171glNewList ( list, mode )
1172 Uint32 list
1173 GLenum mode
1174 CODE:
1175 glNewList(list,mode);
1176
1177void
1178glEndList ()
1179 CODE:
1180 glEndList();
1181
1182void
1183glDeleteLists ( base, count )
1184 Uint32 base
1185 Uint32 count
1186 CODE:
1187 glDeleteLists(base, count);
1188
1189void
1190glCallList ( list )
1191 Uint32 list
1192 CODE:
1193 glCallList(list);
1194
1195Uint32
1196glIsList ( list )
1197 Uint32 list
1198 CODE:
1199 RETVAL = glIsList(list);
1200 OUTPUT:
1201 RETVAL
1202
1203void
1204glListBase ( base )
1205 Uint32 base
1206 CODE:
1207 glListBase(base);
1208
1209void
1210glCallLists ( ... )
1211 CODE:
1212 int *i, j;
1213 if ( items > 0 ) {
1214 i = (int*)safemalloc(sizeof(int)* (items));
1215 for ( j = 0; j < items; j++ ) {
1216 i[j] = SvIV(ST(j));
1217 }
1218 } else {
1219 Perl_croak(aTHX_ "usage: SDL::OpenGL::CallLists(type,...)");
1220 }
1221 glCallLists(items, GL_INT, i);
1222 safefree(i);
1223
1224void
1225glCallListsString ( string )
1226 SV* string
1227 CODE:
1228 char *str;
1229 STRLEN len;
1230 str = SvPV(string,len);
1231 glCallLists(len,GL_BYTE,str);
1232
1233void
4fb8d960 1234glRasterPos ( x, y, ... )
8fde61e3 1235 double x
1236 double y
8fde61e3 1237 CODE:
4fb8d960 1238 if (items == 2)
1239 {
1240 glRasterPos2d (x,y);
1241 }
1242 else if (items == 3)
1243 {
1244 double z = SvNV (ST(2));
1245 glRasterPos3d (x,y,z);
1246 }
1247 else if (items == 4)
1248 {
1249 double z = SvNV (ST(2));
1250 double w = SvNV (ST(3));
1251 glRasterPos4d (x,y,z,w);
8fde61e3 1252 }
1253
1254void
1255glBitmap ( width, height, x1, y1, x2, y2, data )
1256 Uint32 width
1257 Uint32 height
1258 double x1
1259 double y1
1260 double x2
1261 double y2
1262 char *data
1263 CODE:
1264 glBitmap(width,height,x1,y1,x2,y2,data);
1265
1266void
1267glDrawPixels ( width, height, format, type, pixels )
1268 Uint32 width
1269 Uint32 height
1270 GLenum format
1271 GLenum type
1272 char *pixels
1273 CODE:
1274 glDrawPixels(width,height,format,type,pixels);
1275
1276
1277SV*
1278glReadPixels ( x, y, width, height, format, type )
1279 Uint32 x
1280 Uint32 y
1281 Uint32 height
1282 Uint32 width
1283 GLenum format
1284 GLenum type
1285 CODE:
1286 int len, size;
1287 char *buf;
1288 size = 1; /* ALPHA, BLUE, GREEN or RED */
1289 if (format == GL_BGR || format == GL_RGB)
1290 size = 3;
1291 if (format == GL_BGRA || format == GL_RGBA)
1292 size = 4;
1293 len = height * width * size; /* in bytes */
1294 RETVAL = newSV(len); /* alloc len+1 bytes */
1295 SvPOK_on(RETVAL); /* make an PV */
1296 buf = SvPVX(RETVAL); /* get ptr to buffer */
1297 glReadPixels(x,y,width,height,format,type,buf);
1298 SvCUR_set(RETVAL, len); /* set real length */
1299 OUTPUT:
1300 RETVAL
1301
1302AV*
1303glReadPixel ( x, y )
1304 Uint32 x
1305 Uint32 y
1306 CODE:
1307 int rgba[4]; /* r,g,b,a */
1308 int i;
1309 glReadPixels(x,y,1,1,GL_RGBA,GL_UNSIGNED_INT,rgba);
1310 RETVAL = newAV();
1311 for ( i = 0; i < 4; i++ ) {
1312 av_push(RETVAL,newSViv(rgba[i]));
1313 }
1314 OUTPUT:
1315 RETVAL
1316
1317void
1318glCopyPixels ( x, y, width, height, buffer )
1319 Sint32 x
1320 Sint32 y
1321 Uint32 width
1322 Uint32 height
1323 GLenum buffer
1324 CODE:
1325 glCopyPixels(x,y,width,height,buffer);
1326
1327void
1328glPixelStore ( name, param )
1329 Sint32 name
1330 double param
1331 CODE:
1332 glPixelStorei(name,param);
1333
1334void
1335glPixelTransfer ( name, ... )
1336 GLenum name
1337 CODE:
1338 switch ( name ) {
1339 case GL_MAP_COLOR:
1340 case GL_MAP_STENCIL:
1341 case GL_INDEX_SHIFT:
1342 case GL_INDEX_OFFSET:
1343 glPixelTransferi(name,SvIV(ST(1)));
1344 break;
1345 default:
1346 glPixelTransferf(name,SvNV(ST(1)));
1347 break;
1348 }
1349
1350void
1351glPixelMap ( type, map, mapsize, values )
1352 GLenum type
1353 GLenum map
1354 Sint32 mapsize
1355 char *values
1356 CODE:
1357 switch (type) {
1358 case GL_UNSIGNED_INT:
1359 glPixelMapuiv(map,mapsize,(GLint*)values);
1360 break;
1361 case GL_UNSIGNED_SHORT:
1362 glPixelMapusv(map,mapsize,(GLushort*)values);
1363 break;
1364 case GL_FLOAT:
1365 glPixelMapfv(map,mapsize,(GLfloat*)values);
1366 break;
1367 }
1368
1369void
1370glPixelZoom ( zoomx, zoomy )
1371 double zoomx
1372 double zoomy
1373 CODE:
1374 glPixelZoom(zoomx,zoomy);
1375
1376#ifdef GL_VERSION_1_3
1377
1378void
1379glColorTable ( target, internalFormat, width, format, type, data )
1380 GLenum target
1381 GLenum internalFormat
1382 Uint32 width
1383 GLenum format
1384 GLenum type
1385 char *data
1386 CODE:
1387 glColorTable(target,internalFormat,width,format,type,data);
1388
1389void
1390glColorTableParameter ( target, name, r, g, b, a)
1391 GLenum target
1392 GLenum name
1393 double r
1394 double g
1395 double b
1396 double a
1397 CODE:
1398 GLfloat vec[4];
1399 vec[0] = r;
1400 vec[1] = g;
1401 vec[2] = b;
1402 vec[3] = a;
1403 glColorTableParameterfv(target,name,vec);
1404
1405void
1406glCopyColorTable ( target, internalFormat, x, y, width )
1407 GLenum target
1408 GLenum internalFormat
1409 Sint32 x
1410 Sint32 y
1411 Uint32 width
1412 CODE:
1413 glCopyColorTable(target,internalFormat,x,y,width);
1414
1415void
1416glColorSubTable ( target, start, count, format, type, data )
1417 Uint32 target
1418 Uint32 start
1419 Uint32 count
1420 Uint32 format
1421 Uint32 type
1422 char *data
1423 CODE:
1424 glColorSubTable(target,start,count,format,type,data);
1425
1426void
1427glCopyColorSubTable ( target, start, x, y, count )
1428 Uint32 target
1429 Uint32 start
1430 Sint32 x
1431 Sint32 y
1432 Uint32 count
1433 CODE:
1434 glCopyColorSubTable(target,start,x,y,count);
1435
1436void
1437glConvolutionFilter2D ( target, internalFormat, width, height, format, type, image )
1438 Uint32 target
1439 Uint32 internalFormat
1440 Uint32 width
1441 Uint32 height
1442 Uint32 format
1443 Uint32 type
1444 char *image
1445 CODE:
1446 glConvolutionFilter2D(target,internalFormat,width,height,format,type,image);
1447
1448void
1449glCopyConvolutionFilter2D ( target, internalFormat, x, y, width, height )
1450 Uint32 target
1451 Uint32 internalFormat
1452 Sint32 x
1453 Sint32 y
1454 Uint32 width
1455 Uint32 height
1456 CODE:
1457 glCopyConvolutionFilter2D(target,internalFormat,x,y,width,height);
1458
1459void
1460glSeparableFilter2D ( target, internalFormat, width, height, format, type, row, column )
1461 Uint32 target
1462 Uint32 internalFormat
1463 Uint32 width
1464 Uint32 height
1465 Uint32 format
1466 Uint32 type
1467 char *row
1468 char *column
1469 CODE:
1470 glSeparableFilter2D(target,internalFormat,width,height,format,type,row,column);
1471
1472void
1473glConvolutionFilter1D ( target, internalFormat, width, format, type, image )
1474 Uint32 target
1475 Uint32 internalFormat
1476 Uint32 width
1477 Uint32 format
1478 Uint32 type
1479 char *image
1480 CODE:
1481 glConvolutionFilter1D(target,internalFormat,width,format,type,image);
1482
1483void
1484glCopyConvolutionFilter1D ( target, internalFormat, x, y, width )
1485 Uint32 target
1486 Uint32 internalFormat
1487 Sint32 x
1488 Sint32 y
1489 Uint32 width
1490 CODE:
1491 glCopyConvolutionFilter1D(target,internalFormat,x,y,width);
1492
1493void
1494glConvolutionParameter ( target, pname, ... )
1495 Uint32 target
1496 Uint32 pname
1497 CODE:
1498 Uint32 pi;
1499 GLfloat pv[4];
1500 switch(pname) {
1501 case GL_CONVOLUTION_BORDER_MODE:
1502 if ( items != 3 )
1503 Perl_croak(aTHX_ "Usage: ConvolutionParameter(target,pname,...)");
1504 pi = SvIV(ST(2));
1505 glConvolutionParameteri(target,pname,pi);
1506 break;
1507 case GL_CONVOLUTION_FILTER_SCALE:
1508 case GL_CONVOLUTION_FILTER_BIAS:
1509 if ( items != 6 )
1510 Perl_croak(aTHX_ "Usage: ConvolutionParameter(target,pname,...)");
1511 pv[0] = (GLfloat)SvNV(ST(2));
1512 pv[1] = (GLfloat)SvNV(ST(3));
1513 pv[2] = (GLfloat)SvNV(ST(4));
1514 pv[3] = (GLfloat)SvNV(ST(5));
1515 glConvolutionParameterfv(target,pname,pv);
1516 break;
1517 default:
1518 Perl_croak(aTHX_ "ConvolutionParameter invalid parameter");
1519 break;
1520 }
1521
1522void
1523glHistogram ( target, width, internalFormat, sink )
1524 Uint32 target
1525 Uint32 width
1526 Uint32 internalFormat
1527 GLboolean sink
1528 CODE:
1529 glHistogram(target,width,internalFormat,sink);
1530
1531void
1532glGetHistogram ( target, reset, format, type, values )
1533 Uint32 target
1534 GLboolean reset
1535 Uint32 format
1536 Uint32 type
1537 char *values
1538 CODE:
1539 glGetHistogram(target,reset,format,type,values);
1540
1541void
1542glResetHistogram ( target )
1543 Uint32 target
1544 CODE:
1545 glResetHistogram(target);
1546
1547void
1548glMinmax ( target, internalFormat, sink )
1549 Uint32 target
1550 Uint32 internalFormat
1551 GLboolean sink
1552 CODE:
1553 glMinmax(target,internalFormat,sink);
1554
1555void
1556glGetMinmax ( target, reset, format, type, values )
1557 Uint32 target
1558 GLboolean reset
1559 Uint32 format
1560 Uint32 type
1561 char *values
1562 CODE:
1563 glGetMinmax(target,reset,format,type,values);
1564
1565void
1566glResetMinmax ( target )
1567 Uint32 target
1568 CODE:
1569 glResetMinmax(target);
1570
1571void
1572glBlendEquation ( mode )
1573 Uint32 mode
1574 CODE:
1575 glBlendEquation(mode);
1576
1577#endif // GL_VERSION_1_3
1578
1579void
1580glTexImage2D ( target, level, internalFormat, width, height, border, format, type, data )
1581 GLenum target
1582 Sint32 level
1583 Sint32 internalFormat
1584 Uint32 width
1585 Uint32 height
1586 Sint32 border
1587 GLenum format
1588 GLenum type
1589 char *data
1590 CODE:
1591 glTexImage2D(target,level,internalFormat,width,height,border,format,type,data);
1592
1593void
1594glCopyTexImage2D ( target, level, internalFormat, x, y, width, height, border )
1595 GLenum target
1596 Sint32 level
1597 Sint32 internalFormat
1598 Sint32 x
1599 Sint32 y
1600 Uint32 width
1601 Uint32 height
1602 Sint32 border
1603 CODE:
1604 glCopyTexImage2D(target,level,internalFormat,x,y,width,height,border);
1605
1606void
1607glTexSubImage2D ( target, level, xoffset, yoffset, width, height, format, type, data )
1608 GLenum target
1609 Sint32 level
1610 Sint32 xoffset
1611 Sint32 yoffset
1612 Uint32 width
1613 Uint32 height
1614 GLenum format
1615 GLenum type
1616 char *data
1617 CODE:
1618 glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,data);
1619
1620void
1621glCopyTexSubImage2D ( target, level, xoffset, yoffset, x, y, width, height )
1622 GLenum target
1623 Sint32 level
1624 Sint32 xoffset
1625 Sint32 yoffset
1626 Sint32 x
1627 Sint32 y
1628 Uint32 width
1629 Uint32 height
1630 CODE:
1631 glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
1632
1633void
1634glTexImage1D ( target, level, internalFormat, width, border, format, type, data )
1635 GLenum target
1636 Sint32 level
1637 Sint32 internalFormat
1638 Uint32 width
1639 Sint32 border
1640 GLenum format
1641 GLenum type
1642 char *data
1643 CODE:
1644 glTexImage1D(target,level,internalFormat,width,border,format,type,data);
1645
1646void
1647glTexSubImage1D ( target, level, xoffset, width, format, type, data )
1648 GLenum target
1649 Sint32 level
1650 Sint32 xoffset
1651 Uint32 width
1652 GLenum format
1653 GLenum type
1654 char *data
1655 CODE:
1656 glTexSubImage1D(target,level,xoffset,width,format,type,data);
1657
1658void
1659glCopyTexImage1D ( target, level, internalFormat, x, y, width, border )
1660 GLenum target
1661 Sint32 level
1662 Sint32 internalFormat
1663 Sint32 x
1664 Sint32 y
1665 Uint32 width
1666 Sint32 border
1667 CODE:
1668 glCopyTexImage1D(target,level,internalFormat,x,y,width,border);
1669
1670void
1671glCopyTexSubImage1D ( target, level, xoffset, x, y, width )
1672 GLenum target
1673 Sint32 level
1674 Sint32 xoffset
1675 Sint32 x
1676 Sint32 y
1677 Uint32 width
1678 CODE:
1679 glCopyTexSubImage1D(target,level,xoffset,x,y,width);
1680
1681#ifdef GL_VERSION_1_3
1682
1683void
1684glTexImage3D ( target, level, internalFormat, width, height, depth, border, format, type, data )
1685 GLenum target
1686 Sint32 level
1687 Sint32 internalFormat
1688 Uint32 width
1689 Uint32 height
1690 Uint32 depth
1691 Sint32 border
1692 GLenum format
1693 GLenum type
1694 char *data
1695 CODE:
1696 glTexImage3D(target,level,internalFormat,width,height,depth,border,format,type,data);
1697
1698void
1699glTexSubImage3D ( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data )
1700 GLenum target
1701 Sint32 level
1702 Sint32 xoffset
1703 Sint32 yoffset
1704 Sint32 zoffset
1705 Uint32 width
1706 Uint32 height
1707 Uint32 depth
1708 GLenum format
1709 GLenum type
1710 char *data
1711 CODE:
1712 glTexSubImage3D(target,level,xoffset,yoffset,zoffset,
1713 width,height,depth,format,type,data);
1714
1715void
1716glCopyTexSubImage3D ( target, level, xoffset, yoffset, zoffset, x, y, width, height )
1717 GLenum target
1718 Sint32 level
1719 Sint32 xoffset
1720 Sint32 yoffset
1721 Sint32 zoffset
1722 Sint32 x
1723 Sint32 y
1724 Uint32 width
1725 Uint32 height
1726 CODE:
1727 glCopyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height);
1728
1729#endif // GL_VERSION_1_3
1730
1731AV*
1732glGenTextures ( n )
1733 Uint32 n;
1734 CODE:
1735 Uint32 i;
1736 Uint32 *names;
1737 names = (Uint32*)safemalloc(sizeof(Uint32)*n);
1738 RETVAL = newAV();
1739 glGenTextures(n,names);
1740 for ( i = 0; i < n; i++ ) {
1741 av_push(RETVAL,newSViv(names[i]));
1742 }
1743 safefree(names);
1744 OUTPUT:
1745 RETVAL
1746
1747GLboolean
1748glIsTexture ( texture )
1749 Uint32 texture
1750 CODE:
1751 RETVAL = glIsTexture(texture);
1752 OUTPUT:
1753 RETVAL
1754
1755void
1756glBindTexture ( target, texture )
1757 GLenum target
1758 Uint32 texture
1759 CODE:
1760 glBindTexture(target,texture);
1761
1762void
1763glDeleteTextures ( ... )
1764 CODE:
1765 Uint32 *textures;
1766 int i;
1767 textures = (Uint32*)safemalloc(sizeof(Uint32) * items);
1768 if ( textures ) {
1769 for ( i = 0; i < items; i++ ) {
1770 textures[i] = SvIV(ST(i));
1771 }
1772 }
1773 glDeleteTextures(items,textures);
1774 safefree(textures);
1775
1776AV*
1777glAreTexturesResident ( ... )
1778 CODE:
1779 Uint32 *textures;
1780 GLboolean *homes;
1781 int i;
1782 RETVAL = newAV();
1783 textures = (Uint32*)safemalloc(sizeof(Uint32) * items);
1784 homes = (GLboolean*)safemalloc(sizeof(GLboolean) * items);
1785 if ( textures ) {
1786 for ( i = 0; i < items; i++ ) {
1787 textures[i] = SvIV(ST(i));
1788 }
1789 }
1790 if ( GL_FALSE != glAreTexturesResident(items,textures,homes)) {
1791 for (i = 0; i < items; i++ ) {
1792 av_push(RETVAL,newSViv(homes[i]));
1793 }
1794 }
1795 safefree(homes);
1796 safefree(textures);
1797 OUTPUT:
1798 RETVAL
1799
1800void
1801glPrioritizeTextures ( n, names, priorities )
1802 Uint32 n
1803 char *names
1804 char *priorities
1805 CODE:
1806 glPrioritizeTextures(n,(GLuint*)names,(const GLclampf *)priorities);
1807
1808void
1809glTexEnv ( target, name, ... )
1810 GLenum target
1811 GLenum name
1812 CODE:
1813 float pv[4];
1814 GLint p;
1815 switch(name) {
1816 case GL_TEXTURE_ENV_MODE:
1817 p = SvIV(ST(2));
1818 glTexEnvi(target,name,p);
1819 break;
1820 case GL_TEXTURE_ENV_COLOR:
1821 pv[0] = SvNV(ST(2));
1822 pv[1] = SvNV(ST(3));
1823 pv[2] = SvNV(ST(4));
1824 pv[3] = SvNV(ST(5));
1825 glTexEnvfv(target,name,pv);
1826 break;
1827 }
1828
1829void
1830glTexCoord ( ... )
1831 CODE:
1832 double s,t,r,q;
1833 if ( items < 1 || items > 4 )
1834 Perl_croak (aTHX_ "usage: SDL::OpenGL::TexCoord(s,[t,[r,[q]]])");
1835 s = t = r = 0.0;
1836 q = 1.0;
1837 switch(items) {
1838 case 4:
1839 q = SvNV(ST(3));
1840 case 3:
1841 r = SvNV(ST(2));
1842 case 2:
1843 t = SvNV(ST(1));
1844 case 1:
1845 s = SvNV(ST(0));
1846 }
1847 glTexCoord4d(s,t,r,q);
1848
1849void
1850glTexParameter ( target, name, ... )
1851 GLenum target
1852 GLenum name
1853 CODE:
1854 GLfloat pv[4];
1855 GLint p;
1856 switch (name) {
1857 case GL_TEXTURE_BORDER_COLOR:
1858 pv[0] = SvNV(ST(2));
1859 pv[1] = SvNV(ST(3));
1860 pv[2] = SvNV(ST(4));
1861 pv[3] = SvNV(ST(5));
1862 glTexParameterfv(target,name,pv);
1863 break;
1864 case GL_TEXTURE_PRIORITY:
1865 case GL_TEXTURE_MIN_LOD:
1866 case GL_TEXTURE_MAX_LOD:
1867 pv[0] = SvNV(ST(2));
1868 glTexParameterf(target,name,pv[0]);
1869 break;
1870 case GL_TEXTURE_BASE_LEVEL:
1871 case GL_TEXTURE_MAX_LEVEL:
1872 default:
1873 p = SvIV(ST(2));
1874 glTexParameteri(target,name,p);
1875 break;
1876 }
1877
1878void
1879glTexGen ( coord, name, ... )
1880 GLenum coord
1881 GLenum name
1882 CODE:
1883 GLdouble *pv;
1884 GLint p;
1885 int i;
1886 switch (name) {
1887 case GL_TEXTURE_GEN_MODE:
1888 p = SvIV(ST(2));
1889 glTexGeni(coord,name,p);
1890 break;
1891 default:
1892 if ( items == 2 )
1893 Perl_croak(aTHX_ "usage: glTexGen(coord,name,...)");
1894 pv = (GLdouble*)safemalloc(sizeof(GLdouble)*(items-2));
1895 for ( i = 0; i < items - 2; i++ ) {
1896 pv[i] = SvNV(ST(i+2));
1897 }
1898 glTexGendv(coord,name,pv);
1899 safefree(pv);
1900 break;
1901 }
1902
1903#ifdef GL_VERSION_1_3
1904
1905void
1906glActiveTextureARB ( texUnit )
1907 GLenum texUnit
1908 CODE:
1909 glActiveTextureARB(texUnit);
1910
1911void
1912glMultiTexCoord ( texUnit, ... )
1913 Uint32 texUnit
1914 CODE:
1915 double s,t,r,q;
1916 if ( items < 2 || items > 5 )
1917 Perl_croak (aTHX_ "usage: SDL::OpenGL::MultiTexCoord(tex,s,[t,[r,[q]]])");
1918 s = t = r = 0.0;
1919 q = 1.0;
1920 switch(items) {
1921 case 5:
1922 q = SvNV(ST(3));
1923 case 4:
1924 r = SvNV(ST(2));
1925 case 3:
1926 t = SvNV(ST(1));
1927 case 2:
1928 s = SvNV(ST(0));
1929 }
1930 glMultiTexCoord4dARB(texUnit,s,t,r,q);
1931
1932#endif // GL_VERSION_1_3
1933
1934void
1935glDrawBuffer ( mode )
1936 GLenum mode
1937 CODE:
1938 glDrawBuffer(mode);
1939
1940void
1941glReadBuffer ( mode )
1942 GLenum mode
1943 CODE:
1944 glReadBuffer(mode);
1945
1946void
1947glIndexMask ( mask )
1948 Uint32 mask
1949 CODE:
1950 glIndexMask(mask);
1951
1952void
1953glColorMask ( red, green, blue, alpha )
1954 GLboolean red
1955 GLboolean green
1956 GLboolean blue
1957 GLboolean alpha
1958 CODE:
1959 glColorMask(red,green,blue,alpha);
1960
1961void
1962glDepthMask ( flag )
1963 GLboolean flag
1964 CODE:
1965 glDepthMask(flag);
1966
1967void
1968glStencilMask ( mask )
1969 Uint32 mask
1970 CODE:
1971 glStencilMask(mask);
1972
1973void
1974glScissor ( x , y, width, height )
1975 Sint32 x
1976 Sint32 y
1977 Uint32 width
1978 Uint32 height
1979 CODE:
1980 glScissor(x,y,width,height);
1981
1982void
1983glAlphaFunc ( func, ref )
1984 GLenum func
1985 double ref
1986 CODE:
1987 glAlphaFunc(func,ref);
1988
1989void
1990glStencilFunc ( func, ref, mask )
1991 GLenum func
1992 Sint32 ref
1993 Uint32 mask
1994 CODE:
1995 glStencilFunc(func,ref,mask);
1996
1997void
1998glStencilOp ( fail, zfail, zpass )
1999 GLenum fail
2000 GLenum zfail
2001 GLenum zpass
2002 CODE:
2003 glStencilOp(fail,zfail,zpass);
2004
2005void
2006glDepthFunc ( func )
2007 GLenum func
2008 CODE:
2009 glDepthFunc(func);
2010
2011void
2012glLogicOp ( opcode )
2013 GLenum opcode
2014 CODE:
2015 glLogicOp(opcode);
2016
2017void
2018glAccum ( op, value )
2019 GLenum op
2020 double value
2021 CODE:
2022 glAccum(op,value);
2023
2024void
2025glMap1 ( target, u1, u2, stride, order, points )
2026 GLenum target
2027 double u1
2028 double u2
2029 Sint32 stride
2030 Sint32 order
2031 char *points
2032 CODE:
2033 glMap1d(target,u1,u2,stride,order,(double*)points);
2034
2035void
2036glEvalCoord1 ( u )
2037 double u
2038 CODE:
2039 glEvalCoord1d(u);
2040
2041void
2042glMapGrid1 ( n, u1, u2 )
2043 Sint32 n
2044 double u1
2045 double u2
2046 CODE:
2047 glMapGrid1d(n,u1,u2);
2048
2049void
2050glEvalMesh1 ( mode, p1, p2 )
2051 GLenum mode
2052 Sint32 p1
2053 Sint32 p2
2054 CODE:
2055 glEvalMesh1(mode,p1,p2);
2056
2057void
2058glMap2 ( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points )
2059 GLenum target
2060 double u1
2061 double u2
2062 Sint32 ustride
2063 Sint32 uorder
2064 double v1
2065 double v2
2066 Sint32 vstride
2067 Sint32 vorder
2068 char *points
2069 CODE:
2070 glMap2d(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,(double*)points);
2071
2072void
2073glEvalCoord2 ( u, v )
2074 double u
2075 double v
2076 CODE:
2077 glEvalCoord2d(u,v);
2078
2079void
2080glMapGrid2 ( nu, u1, u2, nv, v1, v2 )
2081 Sint32 nu
2082 double u1
2083 double u2
2084 Sint32 nv
2085 double v1
2086 double v2
2087 CODE:
2088 glMapGrid2d(nu,u1,u2,nv,v1,v2);
2089
2090void
2091glEvalMesh2 ( mode, i1, i2, j1, j2 )
2092 GLenum mode
2093 Sint32 i1
2094 Sint32 i2
2095 Sint32 j1
2096 Sint32 j2
2097 CODE:
2098 glEvalMesh2(mode,i1,i2,j1,j2);
2099
2100GLenum
2101glGetError ( )
2102 CODE:
2103 RETVAL = glGetError();
2104 OUTPUT:
2105 RETVAL
2106
2107GLint
2108glRenderMode ( mode )
2109 GLenum mode
2110 CODE:
2111 RETVAL = glRenderMode( mode );
2112 OUTPUT:
2113 RETVAL
2114
2115void
2116glInitNames ( )
2117 CODE:
2118 glInitNames();
2119
2120void
2121glPushName ( name )
2122 GLuint name
2123 CODE:
2124 glPushName(name);
2125
2126void
2127glPopName ( )
2128 CODE:
2129 glPopName();
2130
2131void
2132glLoadName ( name )
2133 GLuint name
2134 CODE:
2135 glLoadName(name);
2136
2137void
2138glFeedbackBuffer ( size, type, buffer )
2139 GLuint size
2140 GLenum type
2141 float* buffer
2142 CODE:
2143 glFeedbackBuffer(size,type,buffer);
2144
2145void
2146glPassThrough ( token )
2147 GLfloat token
2148 CODE:
2149 glPassThrough(token);
2150
2151
2152#endif
2153
2154#ifdef HAVE_GLU
2155
2156void
2157gluLookAt ( eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz )
2158 double eyex
2159 double eyey
2160 double eyez
2161 double centerx
2162 double centery
2163 double centerz
2164 double upx
2165 double upy
2166 double upz
2167 CODE:
2168 gluLookAt(eyex,eyey,eyez,centerx,centery,centerz,upx,upy,upz);
2169
2170void
2171gluPerspective ( fovy, aspect, n, f )
2172 double fovy
2173 double aspect
2174 double n
2175 double f
2176 CODE:
2177 gluPerspective(fovy,aspect,n,f);
2178
2179void
2180gluPickMatrix ( x, y, delx, dely, viewport )
2181 double x
2182 double y
2183 double delx
2184 double dely
2185 GLint* viewport
2186 CODE:
2187 gluPickMatrix(x,y,delx,dely,viewport);
2188
2189void
2190gluOrtho2D ( left, right, bottom, top )
2191 double left
2192 double right
2193 double bottom
2194 double top
2195 CODE:
2196 gluOrtho2D(left,right,bottom,top);
2197
2198int
2199gluScaleImage ( format, widthin, heightin, typein, datain, widthout, heightout, typeout, dataout )
2200 GLenum format
2201 Uint32 widthin
2202 Uint32 heightin
2203 GLenum typein
2204 char *datain
2205 Uint32 widthout
2206 Uint32 heightout
2207 GLenum typeout
2208 char *dataout
2209 CODE:
2210 RETVAL = gluScaleImage(format,widthin,heightin,typein,datain,
2211 widthout,heightout,typeout,dataout);
2212 OUTPUT:
2213 RETVAL
2214
2215int
2216gluBuild1DMipmaps ( target, internalFormat, width, format, type, data )
2217 GLenum target
2218 Sint32 internalFormat
2219 Uint32 width
2220 GLenum format
2221 GLenum type
2222 char *data
2223 CODE:
2224 RETVAL = gluBuild1DMipmaps(target,internalFormat,width,format,type,data);
2225 OUTPUT:
2226 RETVAL
2227
2228int
2229gluBuild2DMipmaps ( target, internalFormat, width, height, format, type, data )
2230 GLenum target
2231 Sint32 internalFormat
2232 Uint32 width
2233 Uint32 height
2234 GLenum format
2235 GLenum type
2236 char *data
2237 CODE:
2238 RETVAL = gluBuild2DMipmaps(target,internalFormat,width,height,format,type,data);
2239 OUTPUT:
2240 RETVAL
2241
2242
2243#if HAVE_GLU_VERSION >= 12
2244int
2245gluBuild3DMipmaps ( target, internalFormat, width, height, depth, format, type, data )
2246 GLenum target
2247 Sint32 internalFormat
2248 Uint32 width
2249 Uint32 height
2250 Uint32 depth
2251 GLenum format
2252 GLenum type
2253 char *data
2254 CODE:
2255 RETVAL = gluBuild3DMipmaps(target,internalFormat,width,height,depth,
2256 format,type,data);
2257 OUTPUT:
2258 RETVAL
2259
2260#else
2261void
2262gluBuild3DMipmaps ( )
2263 CODE:
2264 Perl_croak (aTHX_ "SDL::OpenGL::Build3DMipmaps requires GLU 1.2");
2265
2266#endif
2267
2268#if HAVE_GLU_VERSION >= 12
2269int
2270gluBuild1DMipmapLevels ( target, internalFormat, width, format, type, level, base, max, data )
2271 GLenum target
2272 Sint32 internalFormat
2273 Uint32 width
2274 GLenum format
2275 GLenum type
2276 Sint32 level
2277 Sint32 base
2278 Sint32 max
2279 char *data
2280 CODE:
2281 RETVAL = gluBuild1DMipmapLevels(target,internalFormat,width,
2282 format,type,level,base,max,data);
2283 OUTPUT:
2284 RETVAL
2285
2286#else
2287void
2288gluBuild1DMipmapLevels ()
2289 CODE:
2290 Perl_croak(aTHX_ "SDL::OpenGL::Build1DMipmapLevels requires GLU 1.2");
2291
2292#endif
2293
2294#if HAVE_GLU_VERSION >= 12
2295int
2296gluBuild2DMipmapLevels ( target, internalFormat, width, height, format, type, level, base, max, data )
2297 GLenum target
2298 Sint32 internalFormat
2299 Uint32 width
2300 Uint32 height
2301 GLenum format
2302 GLenum type
2303 Sint32 level
2304 Sint32 base
2305 Sint32 max
2306 char *data
2307 CODE:
2308 RETVAL = gluBuild2DMipmapLevels(target,internalFormat,width,height,
2309 format,type,level,base,max,data);
2310 OUTPUT:
2311 RETVAL
2312
2313#else
2314void
2315gluBuild2DMipmapLevels ()
2316 CODE:
2317 Perl_croak(aTHX_ "SDL::OpenGL::Build2DMipmapLevels requires GLU 1.2");
2318
2319#endif
2320
2321#if HAVE_GLU_VERSION >= 12
2322int
2323gluBuild3DMipmapLevels ( target, internalFormat, width, height, depth, format, type, level, base, max, data )
2324 GLenum target
2325 Sint32 internalFormat
2326 Uint32 width
2327 Uint32 height
2328 Uint32 depth
2329 GLenum format
2330 GLenum type
2331 Sint32 level
2332 Sint32 base
2333 Sint32 max
2334 char *data
2335 CODE:
2336 RETVAL = gluBuild3DMipmapLevels(target,internalFormat,width,height,depth,
2337 format,type,level,base,max,data);
2338 OUTPUT:
2339 RETVAL
2340
2341#else
2342void
2343gluBuild3DMipmapLevels ()
2344 CODE:
2345 Perl_croak(aTHX_ "SDL::OpenGL::Build3DMipmapLevels requires GLU 1.2");
2346
2347#endif
2348
2349char*
2350gluErrorString ( code )
2351 GLenum code
2352 CODE:
2353 RETVAL = (char*)gluErrorString(code);
2354 OUTPUT:
2355 RETVAL
2356
2357GLUnurbsObj*
2358gluNewNurbsRenderer ()
2359 CODE:
2360 RETVAL = gluNewNurbsRenderer();
2361 OUTPUT:
2362 RETVAL
2363
2364void
2365gluDeleteNurbsRenderer ( obj )
2366 GLUnurbsObj *obj
2367 CODE:
2368 gluDeleteNurbsRenderer(obj);
2369
2370void
2371gluNurbsProperty ( obj, property, value )
2372 GLUnurbsObj *obj
2373 GLenum property
2374 double value
2375 CODE:
2376 gluNurbsProperty(obj,property,(float)value);
2377
2378void
2379gluLoadSamplingMatrices ( obj, mm, pm, vp )
2380 GLUnurbsObj *obj
2381 char *mm
2382 char *pm
2383 char *vp
2384 CODE:
2385 gluLoadSamplingMatrices(obj,(GLfloat*)mm,(GLfloat*)pm,(GLint*)vp);
2386
2387double
2388gluGetNurbsProperty ( obj, property )
2389 GLUnurbsObj *obj
2390 GLenum property
2391 CODE:
2392 float f;
2393 gluGetNurbsProperty(obj,property,&f);
2394 RETVAL = (double)f;
2395 OUTPUT:
2396 RETVAL
2397
2398void
2399gluNurbsCallback ( obj, which, cb )
2400 GLUnurbsObj *obj
2401 GLenum which
2402 SV *cb
2403 CODE:
2404 switch(which) {
2405 case GLU_ERROR:
2406 sdl_perl_nurbs_error_hook = cb;
2407 gluNurbsCallback(obj,GLU_ERROR,(GLvoid*)sdl_perl_nurbs_error_callback);
2408 break;
2409#ifdef GLU_NURBS_BEGIN
2410 case GLU_NURBS_BEGIN:
2411 case GLU_NURBS_BEGIN_DATA:
2412 gluNurbsCallbackData(obj,(void*)cb);
2413 gluNurbsCallback(obj,GLU_NURBS_BEGIN_DATA,
2414 (GLvoid*)sdl_perl_nurbs_being_callback);
2415 break;
2416 case GLU_NURBS_TEXTURE_COORD:
2417 case GLU_NURBS_TEXTURE_COORD_DATA:
2418 gluNurbsCallbackData(obj,(void*)cb);
2419 gluNurbsCallback(obj,GLU_NURBS_TEXTURE_COORD_DATA,
2420 (GLvoid*)sdl_perl_nurbs_multi_callback);
2421 break;
2422 case GLU_NURBS_COLOR:
2423 case GLU_NURBS_COLOR_DATA:
2424 gluNurbsCallbackData(obj,(void*)cb);
2425 gluNurbsCallback(obj,GLU_NURBS_COLOR_DATA,
2426 (GLvoid*)sdl_perl_nurbs_multi_callback);
2427 break;
2428 case GLU_NURBS_NORMAL:
2429 case GLU_NURBS_NORMAL_DATA:
2430 gluNurbsCallbackData(obj,(void*)cb);
2431 gluNurbsCallback(obj,GLU_NURBS_NORMAL_DATA,
2432 (GLvoid*)sdl_perl_nurbs_multi_callback);
2433 break;
2434 case GLU_NURBS_VERTEX:
2435 case GLU_NURBS_VERTEX_DATA:
2436 gluNurbsCallbackData(obj,(void*)cb);
2437 gluNurbsCallback(obj,GLU_NURBS_VERTEX_DATA,
2438 (GLvoid*)sdl_perl_nurbs_multi_callback);
2439 break;
2440 case GLU_NURBS_END:
2441 case GLU_NURBS_END_DATA:
2442 gluNurbsCallbackData(obj,(void*)cb);
2443 gluNurbsCallback(obj,GLU_NURBS_END_DATA,
2444 (GLvoid*)sdl_perl_nurbs_end_callback);
2445 break;
2446#endif
2447 default:
2448 Perl_croak(aTHX_ "SDL::OpenGL::NurbsCallback - invalid type");
2449 }
2450
2451void
2452gluNurbsCallbackData ( obj, cb )
2453 GLUnurbsObj *obj
2454 SV *cb
2455 CODE:
2456 gluNurbsCallbackData(obj,(void*)cb);
2457
2458void
2459gluBeginSurface ( obj )
2460 GLUnurbsObj *obj
2461 CODE:
2462 gluBeginSurface(obj);
2463
2464void
2465gluEndSurface ( obj )
2466 GLUnurbsObj *obj
2467 CODE:
2468 gluEndSurface(obj);
2469
2470void
2471gluNurbsSurface ( obj, uknot_count, uknot, vknot_count, vknot, u_stride, v_stride, ctlarray, uorder, vorder, type )
2472 GLUnurbsObj *obj
2473 Sint32 uknot_count
2474 char *uknot
2475 Sint32 vknot_count
2476 char *vknot
2477 Sint32 u_stride
2478 Sint32 v_stride
2479 char *ctlarray
2480 Sint32 uorder
2481 Sint32 vorder
2482 GLenum type
2483 CODE:
2484 gluNurbsSurface(obj,uknot_count,(GLfloat*)uknot,vknot_count,(GLfloat*)vknot,
2485 u_stride,v_stride,(GLfloat*)ctlarray,uorder,vorder,type);
2486
2487void
2488gluBeginCurve ( obj )
2489 GLUnurbsObj *obj
2490 CODE:
2491 gluBeginCurve(obj);
2492
2493void
2494gluEndCurve ( obj )
2495 GLUnurbsObj *obj
2496 CODE:
2497 gluEndCurve(obj);
2498
2499void
2500gluNurbsCurve ( obj, uknot_count, uknot, u_stride, ctlarray, uorder, type )
2501 GLUnurbsObj *obj
2502 Sint32 uknot_count
2503 char *uknot
2504 Sint32 u_stride
2505 char *ctlarray
2506 Sint32 uorder
2507 GLenum type
2508 CODE:
2509 gluNurbsCurve(obj,uknot_count,(GLfloat*)uknot,u_stride,(GLfloat*)ctlarray,
2510 uorder,type);
2511
2512void
2513gluBeginTrim ( obj )
2514 GLUnurbsObj *obj
2515 CODE:
2516 gluBeginTrim(obj);
2517
2518void
2519gluEndTrim ( obj )
2520 GLUnurbsObj *obj
2521 CODE:
2522 gluEndTrim(obj);
2523
2524void
2525gluPwlCurve ( obj, count, array, stride, type )
2526 GLUnurbsObj *obj
2527 Sint32 count
2528 char *array
2529 Sint32 stride
2530 GLenum type
2531 CODE:
2532 gluPwlCurve(obj,count,(GLfloat*)array,stride,type);
2533
2534AV*
2535gluUnProject ( winx, winy, winz, mm, pm, vp )
2536 double winx
2537 double winy
2538 double winz
2539 char *mm
2540 char *pm
2541 char *vp
2542 CODE:
2543 GLdouble objx, objy, objz;
2544 RETVAL = newAV();
2545 av_push(RETVAL,newSViv(gluUnProject(winx,winy,winz,(GLdouble*)mm,
2546 (GLdouble*)pm,(GLint*)vp,&objx,&objy,&objz)));
2547 av_push(RETVAL,newSVnv((double)objx));
2548 av_push(RETVAL,newSVnv((double)objy));
2549 av_push(RETVAL,newSVnv((double)objz));
2550 OUTPUT:
2551 RETVAL
2552
2553
2554#ifdef GL_VERSION_1_3
2555
2556AV*
2557gluUnProject4 ( winx, winy, winz, clipw, mm, pm, vp, n, f )
2558 double winx
2559 double winy
2560 double winz
2561 double clipw
2562 char *mm
2563 char *pm
2564 char *vp
2565 double n
2566 double f
2567 CODE:
2568 GLdouble objx, objy, objz, objw;
2569 RETVAL = newAV();
2570 av_push(RETVAL,newSViv(gluUnProject4(winx,winy,winz,clipw,(GLdouble*)mm,
2571 (GLdouble*)pm,(GLint*)vp,(GLclampd)n,(GLclampd)f,
2572 &objx,&objy,&objz,&objw)));
2573 av_push(RETVAL,newSVnv((double)objx));
2574 av_push(RETVAL,newSVnv((double)objy));
2575 av_push(RETVAL,newSVnv((double)objz));
2576 av_push(RETVAL,newSVnv((double)objw));
2577 OUTPUT:
2578 RETVAL
2579
2580#endif // GL_VERSION_1_3
2581
2582AV*
2583gluProject ( objx, objy, objz, mm, pm, vp )
2584 double objx
2585 double objy
2586 double objz
2587 char *mm
2588 char *pm
2589 char *vp
2590 CODE:
2591 GLdouble winx, winy, winz;
2592 RETVAL = newAV();
2593 av_push(RETVAL,newSViv(gluUnProject(objx,objy,objz,(GLdouble*)mm,
2594 (GLdouble*)pm,(GLint*)vp,&winx,&winy,&winz)));
2595 av_push(RETVAL,newSVnv((double)winx));
2596 av_push(RETVAL,newSVnv((double)winy));
2597 av_push(RETVAL,newSVnv((double)winz));
2598 OUTPUT:
2599 RETVAL
2600
2601#ifdef GL_VERSION_1_2
2602
2603GLUtesselator*
2604gluNewTess ()
2605 CODE:
2606 RETVAL = gluNewTess();
2607 OUTPUT:
2608 RETVAL
2609
2610void
2611gluTessCallback ( tess, type )
2612 GLUtesselator *tess
2613 GLenum type
2614 CODE:
2615 switch(type) {
2616 case GLU_TESS_BEGIN:
2617 case GLU_TESS_BEGIN_DATA:
2618 gluTessCallback(tess,GLU_TESS_BEGIN_DATA,
2619 (GLvoid*)sdl_perl_tess_begin_callback);
2620 break;
2621
2622 case GLU_TESS_EDGE_FLAG:
2623 case GLU_TESS_EDGE_FLAG_DATA:
2624 gluTessCallback(tess,GLU_TESS_EDGE_FLAG_DATA,
2625 (GLvoid*)sdl_perl_tess_edge_flag_callback);
2626 break;
2627
2628 case GLU_TESS_VERTEX:
2629 case GLU_TESS_VERTEX_DATA:
2630 gluTessCallback(tess,GLU_TESS_VERTEX_DATA,
2631 (GLvoid*)sdl_perl_tess_vertex_callback);
2632 break;
2633
2634 case GLU_TESS_END:
2635 case GLU_TESS_END_DATA:
2636 gluTessCallback(tess,GLU_TESS_END_DATA,
2637 (GLvoid*)sdl_perl_tess_end_callback);
2638 break;
2639
2640 case GLU_TESS_COMBINE:
2641 case GLU_TESS_COMBINE_DATA:
2642 gluTessCallback(tess,GLU_TESS_COMBINE_DATA,
2643 (GLvoid*)sdl_perl_tess_combine_callback);
2644 break;
2645
2646 case GLU_TESS_ERROR:
2647 case GLU_TESS_ERROR_DATA:
2648 gluTessCallback(tess,GLU_TESS_ERROR_DATA,
2649 (GLvoid*)sdl_perl_tess_error_callback);
2650 break;
2651 }
2652
2653void
2654gluTessProperty ( tessobj, property, value )
2655 GLUtesselator *tessobj
2656 Uint32 property
2657 double value
2658 CODE:
2659 gluTessProperty(tessobj,property,value);
2660
2661double
2662gluGetTessProperty ( tessobj, property )
2663 GLUtesselator *tessobj
2664 Uint32 property
2665 CODE:
2666 gluGetTessProperty(tessobj,property,&RETVAL);
2667 OUTPUT:
2668 RETVAL
2669
2670void
2671gluTessNormal ( tessobj, x, y, z )
2672 GLUtesselator *tessobj
2673 double x
2674 double y
2675 double z
2676 CODE:
2677 gluTessNormal(tessobj,x,y,z);
2678
2679void
2680gluTessBeginPolygon ( tessobj, cb )
2681 GLUtesselator *tessobj
2682 SV *cb
2683 CODE:
2684 gluTessBeginPolygon(tessobj,cb);
2685
2686void
2687gluTessEndPolygon ( tessobj )
2688 GLUtesselator *tessobj
2689 CODE:
2690 gluTessEndPolygon(tessobj);
2691
2692void
2693gluTessBeginContour ( tessobj )
2694 GLUtesselator *tessobj
2695 CODE:
2696 gluTessBeginContour(tessobj);
2697
2698void
2699gluTessEndContour ( tessobj )
2700 GLUtesselator *tessobj
2701 CODE:
2702 gluTessEndContour(tessobj);
2703
2704void
2705gluDeleteTess ( tessobj )
2706 GLUtesselator *tessobj
2707 CODE:
2708 gluDeleteTess(tessobj);
2709
2710void
2711gluTessVertex ( tessobj, coords, vd )
2712 GLUtesselator *tessobj
2713 char *coords
2714 char *vd
2715 CODE:
2716 gluTessVertex(tessobj,(GLdouble*)coords,vd);
2717
5a2c431f 2718#endif
4db254ce 2719
2720GLUquadric *
2721gluNewQuadric ()
2722 CODE:
2723 RETVAL = gluNewQuadric ();
2724 OUTPUT:
2725 RETVAL
2726
2727void
2728gluDeleteQuadric (quad)
2729 GLUquadric *quad
2730 CODE:
2731 gluDeleteQuadric(quad);
2732
2733void
2734gluQuadricNormals ( quad, normal )
2735 GLUquadric *quad
2736 GLenum normal
2737 CODE:
2738 gluQuadricNormals(quad, normal);
2739
2740
2741void
2742gluQuadricTexture ( quad, texture )
2743 GLUquadric *quad
2744 GLboolean texture
2745 CODE:
2746 gluQuadricTexture ( quad, texture );
2747
2748void
2749gluCylinder ( quad, base, top, height, slices, stacks )
2750 GLUquadric *quad
2751 GLdouble base
2752 GLdouble top
2753 GLdouble height
2754 GLint slices
2755 GLint stacks
2756 CODE:
2757 gluCylinder ( quad, base, top, height, slices, stacks );
5a2c431f 2758
4db254ce 2759void
2760gluDisk ( quad, inner, outer, slices, loops )
2761 GLUquadric *quad
2762 GLdouble inner
2763 GLdouble outer
2764 GLint slices
2765 GLint loops
2766 CODE:
2767 gluDisk ( quad, inner, outer, slices, loops );
2768
2769void
2770gluPartialDisk ( quad, inner, outer, slices, loops, start, sweep )
2771 GLUquadric *quad
2772 GLdouble inner
2773 GLdouble outer
2774 GLint slices
2775 GLint loops
2776 GLdouble start
2777 GLdouble sweep
2778
2779 CODE:
2780 gluPartialDisk ( quad, inner, outer, slices, loops, start, sweep );
2781
2782void
2783gluSphere ( quad, radius, slices, stacks )
2784 GLUquadric *quad
2785 GLdouble radius
2786 GLint slices
2787 GLint stacks
2788 CODE:
2789 gluSphere ( quad, radius, slices, stacks );
8fde61e3 2790
5a2c431f 2791
8fde61e3 2792#endif
2793
Unnamed repository; edit this file to name it for gitweb.