Set the out buffer count to zero on read error.
[wine] / dlls / glut32 / glut.c
1 /*
2  * Copyright 2003 Jacek Caban
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17  */
18
19 #include "windef.h"
20
21 static void (*__glutExitFunc)(int ret) = 0;
22
23 /***************************************************
24  *      DllMain [glut32.init]
25  */
26 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
27 {
28    if(fdwReason == DLL_PROCESS_DETACH)  {
29       if(__glutExitFunc)
30          __glutExitFunc(0);
31    }
32    return TRUE;
33 }
34
35 /****************************************************
36  *      glutGetColor (glut32.@)
37  */
38 extern float glutGetColor(int arg1, int arg2);
39 float WINAPI wine_glutGetColor(int arg1, int arg2)
40 {
41    return glutGetColor(arg1, arg2);
42 }
43
44 /****************************************************
45  *      glutBitmapLength (glut32.@)
46  */
47 extern int glutBitmapLength(void *arg1, void *arg2);
48 int WINAPI wine_glutBitmapLength(void *arg1, void *arg2)
49 {
50    return glutBitmapLength(arg1, arg2);
51 }
52
53 /****************************************************
54  *      glutBitmapWith (glut32.@)
55  */
56 extern int glutBitmapWidth(void *arg1, int arg2);
57 int WINAPI wine_glutBitmapWidth(void *arg1, int arg2)
58 {
59    return glutBitmapWidth(arg1, arg2);
60 }
61
62 /****************************************************
63  *      glutCreateMenu (glut32.@)
64  */
65 extern int glutCreateMenu(void *arg);
66 int WINAPI wine_glutCreateMenu(void *arg)
67 {
68    return glutCreateMenu(arg);
69 }
70
71 /****************************************************
72  *      __glutCreateMenuWithExit (glut32.@)
73  */
74 int WINAPI wine___glutCreateMenuWithExit(void *arg1, void (*exitfunc)(int))
75 {
76    __glutExitFunc = exitfunc;
77    return glutCreateMenu(arg1);
78 }
79
80 /*****************************************************
81  *      glutCreateSubWindow (glut32.@)
82  */
83 extern int glutCreateSubWindow(int arg1, int arg2, int arg3, int arg4, int arg5);
84 int WINAPI wine_glutCreateSubWindow(int arg1, int arg2, int arg3, int arg4, int arg5)
85 {
86    return glutCreateSubWindow(arg1, arg2, arg3, arg4, arg5);
87 }
88
89 /*****************************************************
90  *      glutCreateWindow (glut32.@)
91  */
92 extern int glutCreateWindow(void *arg);
93 int WINAPI wine_glutCreateWindow(void *arg)
94 {
95    return glutCreateWindow(arg);
96 }
97
98 /****************************************************
99  *      __glutCreateWindowWithExit (glut32.@)
100  */
101 int WINAPI wine___glutCreateWindowWithExit(void *arg, void (*exitfunc)(int))
102 {
103    __glutExitFunc = exitfunc;
104    return glutCreateWindow(arg);
105 }
106
107 /*****************************************************
108  *      glutDeviceGet (glut32.@)
109  */
110 extern int glutDeviceGet(int arg);
111 int WINAPI wine_glutDeviceGet(int arg)
112 {
113    return glutDeviceGet(arg);
114 }
115
116 /****************************************************
117  *      glutEnterGameMode (glut32.@)
118  */
119 extern int glutEnterGameMode(void);
120 int WINAPI wine_glutEnterGameMode(void)
121 {
122    return glutEnterGameMode();
123 }
124
125 /****************************************************
126  *      glutExtensionSupported (glut32.@)
127  */
128 extern int glutExtensionSupported(void *arg);
129 int WINAPI wine_glutExtensionSupported(void *arg)
130 {
131    return glutExtensionSupported(arg);
132 }
133
134 /****************************************************
135  *      glutGameModeGet (glut32.@)
136  */
137 extern int glutGameModeGet(int arg);
138 int WINAPI wine_glutGameModeGet(int arg)
139 {
140    return glutGameModeGet(arg);
141 }
142
143 /****************************************************
144  *      glutGetMenu (glut32.@)
145  */
146 extern int glutGetMenu(void);
147 int WINAPI wine_glutGetMenu(void)
148 {
149    return wine_glutGetMenu();
150 }
151
152 /****************************************************
153  *      glutGetModifiers (glut32.@)
154  */
155 extern int glutGetModifiers(void);
156 int WINAPI wine_glutGetModifiers(void)
157 {
158    return glutGetModifiers();
159 }
160
161 /****************************************************
162  *      glutGet (glut32.@)
163  */
164 extern int glutGet(int arg);
165 int WINAPI wine_glutGet(int arg)
166 {
167    return glutGet(arg);
168 }
169
170 /****************************************************
171  *      glutGetWindow (glut32.@)
172  */
173 extern int glutGetWindow(void);
174 int WINAPI wine_glutGetWindow(void)
175 {
176    return glutGetWindow();
177 }
178
179 /****************************************************
180  *      glutLayerGet (glut32.@)
181  */
182 extern int glutLayerGet(int arg);
183 int WINAPI wine_glutLayerGet(int arg)
184 {
185    return glutLayerGet(arg);
186 }
187
188 /****************************************************
189  *      glutStrokeLength (glut32.@)
190  */
191 extern int glutStrokeLength(void *arg1, void* arg2);
192 int WINAPI wine_glutStrokeLength(void *arg1, void *arg2)
193 {
194    return glutStrokeLength(arg1, arg2);
195 }
196
197 /****************************************************
198  *      glutStrokeWidth (glut32.@)
199  */
200 extern int glutStrokeWidth(void *arg1, int arg2);
201 int WINAPI wine_glutStrokeWidth(void *arg1, int arg2)
202 {
203    return glutStrokeWidth(arg1, arg2);
204 }
205
206 /****************************************************
207  *      glutVideoResizeGet (glut32.@)
208  */
209 extern int glutVideoResizeGet(int arg);
210 int WINAPI wine_glutVideoResizeGet(int arg)
211 {
212    return glutVideoResizeGet(arg);
213 }
214
215 /****************************************************
216  *      glutAddMenuEntry (glut32.@)
217  */
218 extern void glutAddMenuEntry(void *arg1, int arg2);
219 void WINAPI wine_glutAddMenuEntry(void *arg1, int arg2)
220 {
221    glutAddMenuEntry(arg1, arg2);
222 }
223
224 /****************************************************
225  *      glutAddSubMenu (glut32.@)
226  */
227 extern void glutAddSubMenu(void *arg1, int arg2);
228 void WINAPI wine_glutAddSubMenu(void *arg1, int arg2)
229 {
230    glutAddSubMenu(arg1, arg2);
231 }
232
233 /****************************************************
234  *      glutAttachMenu (glut32.@)
235  */
236 extern void glutAttachMenu(int arg);
237 void WINAPI wine_glutAttachMenu(int arg)
238 {
239    glutAttachMenu(arg);
240 }
241
242 /****************************************************
243  *      glutBitmapCharacter (glut32.@)
244  */
245 extern void glutBitmapCharacter(void *arg1, int arg2);
246 void WINAPI wine_glutBitmapCharacter(void *arg1, int arg2)
247 {
248    glutBitmapCharacter(arg1, arg2);
249 }
250
251 /****************************************************
252  *      glutButtonBoxFunc (glut32.@)
253  */
254 extern void glutButtonBoxFunc(void *arg);
255 void WINAPI wine_glutButtonBoxFunc(void *arg)
256 {
257    glutButtonBoxFunc(arg);
258 }
259
260 /****************************************************
261  *      glutChangeToMenuEntry (glut32.@)
262  */
263 extern void glutChangeToMenuEntry(int arg1, void *arg2, int arg3);
264 void WINAPI wine_glutChangeToMenuEntry(int arg1, void *arg2, int arg3)
265 {
266    glutChangeToMenuEntry(arg1, arg2, arg3);
267 }
268
269 /****************************************************
270  *      glutChangeToSubMenu (glut32.@)
271  */
272 extern void glutChangeToSubMenu(int arg1, void *arg2, int arg3);
273 void WINAPI wine_glutChangeToSubMenu(int arg1, void *arg2, int arg3)
274 {
275    glutChangeToSubMenu(arg1, arg2, arg3);
276 }
277
278 /****************************************************
279  *      glutCopyColormap (glut32.@)
280  */
281 extern void glutCopyColormap(int arg);
282 void WINAPI wine_glutCopyColormap(int arg)
283 {
284    glutCopyColormap(arg);
285 }
286
287 /****************************************************
288  *      glutDestroyMenu (glut32.@)
289  */
290 extern void glutDestroyMenu(int arg);
291 void WINAPI wine_glutDestroyMenu(int arg)
292 {
293    glutDestroyMenu(arg);
294 }
295
296 /****************************************************
297  *      glutDestroyWindow (glut32.@)
298  */
299 extern void glutDestroyWindow(int arg);
300 void WINAPI wine_glutDestroyWindow(int arg)
301 {
302    glutDestroyWindow(arg);
303 }
304
305 /****************************************************
306  *      glutDetachMenu (glut32.@)
307  */
308 extern void glutDetachMenu(int arg);
309 void WINAPI wine_glutDetachMenu(int arg)
310 {
311    glutDetachMenu(arg);
312 }
313
314 /****************************************************
315  *      glutDialsFunc (glut32.@)
316  */
317 extern void glutDialsFunc(void *arg);
318 void WINAPI wine_glutDialsFunc(void *arg)
319 {
320    glutDialsFunc(arg);
321 }
322
323 /*******************************************************
324  *      glutDisplayFunc (glut32.@)
325  */
326 extern void glutDisplayFunc(void *arg);
327 void WINAPI wine_glutDisplayFunc(void *arg)
328 {
329    glutDisplayFunc(arg);
330 }
331
332 /*******************************************************
333  *      glutEntryFunc (glut32.@)
334  */
335 extern void glutEntryFunc(void *arg);
336 void WINAPI wine_glutEntryFunc(void *arg)
337 {
338    glutEntryFunc(arg);
339 }
340
341 /*******************************************************
342  *      glutEstablishOverlay (glut32.@)
343  */
344 extern void glutEstablishOverlay(void);
345 void WINAPI wine_glutEstablishOverlay(void)
346 {
347    glutEstablishOverlay();
348 }
349
350 /*******************************************************
351  *      glutForceJoystickFunc (glut32.@)
352  */
353 extern void glutForceJoystickFunc(void);
354 void WINAPI wine_glutForceJoystickFunc(void)
355 {
356    glutForceJoystickFunc();
357 }
358
359 /*******************************************************
360  *      glutFullScreen (glut32.@)
361  */
362 extern void glutFullScreen(void);
363 void WINAPI wine_glutFullScreen(void)
364 {
365    glutFullScreen();
366 }
367
368 /*******************************************************
369  *      glutGameModeString (glut32.@)
370  */
371 extern void glutGameModeString(void *arg);
372 void WINAPI wine_glutGameModeString(void *arg)
373 {
374    glutGameModeString(arg);
375 }
376
377 /*******************************************************
378  *      glutHideOverlay (glut32.@)
379  */
380 extern void glutHideOverlay(void);
381 void WINAPI wine_glutHideOverlay(void)
382 {
383    glutHideOverlay();
384 }
385
386 /*******************************************************
387  *      glutHideWindow (glut32.@)
388  */
389 extern void glutHideWindow(void);
390 void WINAPI wine_glutHideWindow(void)
391 {
392    glutHideWindow();
393 }
394
395 /*******************************************************
396  *      glutIconifyWindow (glut32.@)
397  */
398 extern void glutIconifyWindow(void);
399 void WINAPI wine_glutIconifyWindow(void)
400 {
401    glutIconifyWindow();
402 }
403
404 /*********************************************
405  *      glutIdleFunc (glut32.@)
406  */
407 extern void glutIdleFunc(void *arg);
408 void WINAPI wine_glutIdleFunc(void *arg)
409 {
410    glutIdleFunc(arg);
411 }
412
413 /*********************************************
414  *      glutIgnoreKeyRepeat (glut32.@)
415  */
416 extern void glutIgnoreKeyRepeat(int arg);
417 void WINAPI wine_glutIgnoreKeyRepeat(int arg)
418 {
419    glutIgnoreKeyRepeat(arg);
420 }
421
422 /**********************************************
423  *      glutInitDisplayMode (glut32.@)
424  */
425 extern void glutInitDisplayMode(unsigned int arg);
426 void WINAPI wine_glutInitDisplayMode(unsigned int arg)
427 {
428    glutInitDisplayMode(arg);
429 }
430
431 /**********************************************
432  *      glutInitDisplayString (glut32.@)
433  */
434 extern void glutInitDisplayString(void *arg);
435 void WINAPI wine_glutInitDisplayString(void *arg)
436 {
437    glutInitDisplayString(arg);
438 }
439
440 /**********************************************
441  *      glutInit (glut32.@)
442  */
443 extern void glutInit(void *arg1, void *arg2);
444 void WINAPI wine_glutInit(void *arg1, void **arg2)
445 {
446    glutInit(arg1, arg2);
447 }
448
449 /**********************************************
450  *      __glutInitWithExit (glut32.@)
451  */
452 void WINAPI wine___glutInitWithExit(void *arg1, void *arg2, void (*exitfunc)(int))
453 {
454    __glutExitFunc = exitfunc;
455    glutInit(arg1, arg2);
456 }
457
458 /***********************************************
459  *      glutInitWindowPosition (glut32.@)
460  */
461 extern void glutInitWindowPosition(int arg1, int arg2);
462 void WINAPI wine_glutInitWindowPosition(int arg1, int arg2)
463 {
464    glutInitWindowPosition(arg1, arg2);
465 }
466
467 /***********************************************
468  *      glutInitWindowSize (glut32.@)
469  */
470 extern void glutInitWindowSize(int arg1, int arg2);
471 void WINAPI wine_glutInitWindowSize(int arg1, int arg2)
472 {
473    glutInitWindowSize(arg1, arg2);
474 }
475
476 /***********************************************
477  *      glutJoystickFunc (glut32.@)
478  */
479 extern void glutJoystickFunc(void *arg1, int arg2);
480 void WINAPI wine_glutJoystickFunc(void *arg1, int arg2)
481 {
482    glutJoystickFunc(arg1, arg2);
483 }
484
485 /***********************************************
486  *      glutKeyboardFunc (glut32.@)
487  */
488 extern void glutKeyboardFunc(void *arg);
489 void WINAPI wine_glutKeyboardFunc(void *arg)
490 {
491    glutKeyboardFunc(arg);
492 }
493
494 /***********************************************
495  *      glutKeyboardUpFunc (glut32.@)
496  */
497 extern void glutKeyboardUpFunc(void *arg);
498 void WINAPI wine_glutKeyboardUpFunc(void *arg)
499 {
500    glutKeyboardUpFunc(arg);
501 }
502
503 /***********************************************
504  *      glutLeaveGameMode (glut32.@)
505  */
506 extern void glutLeaveGameMode(void);
507 void WINAPI wine_glutLeaveGameMode(void)
508 {
509    glutLeaveGameMode();
510 }
511
512 /***********************************************
513  *      glutMainLoop (glut32.@)
514  */
515 extern void glutMainLoop(void);
516 void WINAPI wine_glutMainLoop(void)
517 {
518    glutMainLoop();
519 }
520
521 /***********************************************
522  *      glutMenuStateFunc(glut32.@)
523  */
524 extern void glutMenuStateFunc(void *arg);
525 void WINAPI wine_glutMenuStateFunc(void *arg)
526 {
527    glutMenuStateFunc(arg);
528 }
529
530 /***********************************************
531  *      glutMenuStatusFunc (glut32.@)
532  */
533 extern void glutMenuStatusFunc(void *arg);
534 void WINAPI wine_glutMenuStatusFunc(void *arg)
535 {
536    glutMenuStatusFunc(arg);
537 }
538
539 /***********************************************
540  *      glutMotionFunc (glut32.@)
541  */
542 extern void glutMotionFunc(void *arg);
543 void WINAPI wine_glutMotionFunc(void *arg)
544 {
545    glutMotionFunc(arg);
546 }
547
548 /********************************************
549  *      glutMouseFunc (glut32.@)
550  */
551 extern void glutMouseFunc(void *arg);
552 void WINAPI wine_glutMouseFunc(void *arg)
553 {
554    glutMouseFunc(arg);
555 }
556
557 /********************************************
558  *      glutOverlayDisplayFunc (glut32.@)
559  */
560 extern void glutOverlayDisplayFunc(void *arg);
561 void WINAPI wine_glutOverlayDisplayFunc(void *arg)
562 {
563    glutOverlayDisplayFunc(arg);
564 }
565
566 /********************************************
567  *      glutPassiveMotionFunc (glut32.@)
568  */
569 extern void glutPassiveMotionFunc(void *arg);
570 void WINAPI wine_glutPassiveMotionFunc(void *arg)
571 {
572    glutPassiveMotionFunc(arg);
573 }
574
575 /********************************************
576  *      glutPopWindow (glut32.@)
577  */
578 extern void glutPopWindow(void);
579 void WINAPI wine_glutPopWindow(void)
580 {
581    glutPopWindow();
582 }
583
584 /********************************************
585  *      glutPositionWindow (glut32.@)
586  */
587 extern void glutPositionWindow(int arg1, int arg2);
588 void WINAPI wine_glutPositionWindow(int arg1, int arg2)
589 {
590    glutPositionWindow(arg1, arg2);
591 }
592
593 /********************************************
594  *      glutPostOverlayRedisplay (glut32.@)
595  */
596 extern void glutPostOverlayRedisplay(void);
597 void WINAPI wine_glutPostOverlayRedisplay(void)
598 {
599    glutPostOverlayRedisplay();
600 }
601
602 /********************************************
603  *      glutPostRedisplay (glut32.@)
604  */
605 extern void glutPostRedisplay(void);
606 void WINAPI wine_glutPostRedisplay(void)
607 {
608    glutPostRedisplay();
609 }
610
611 /********************************************
612  *      glutPostWindowOverlayRedisplay (glut32.@)
613  */
614 extern void glutPostWindowOverlayRedisplay(int arg);
615 void WINAPI wine_glutPostWindowOverlayRedisplay(int arg)
616 {
617    glutPostWindowOverlayRedisplay(arg);
618 }
619
620 /********************************************
621  *      glutPostWindowRedisplay (glut32.@)
622  */
623 extern void glutPostWindowRedisplay(int arg);
624 void WINAPI wine_glutPostWindowRedisplay(int arg)
625 {
626    glutPostWindowRedisplay(arg);
627 }
628
629 /********************************************
630  *      glutPushWindow (glut32.@)
631  */
632 extern void glutPushWindow(void);
633 void WINAPI wine_glutPushWindow(void)
634 {
635    glutPushWindow();
636 }
637
638 /********************************************
639  *      glutRemoveMenuItem (glut32.@)
640  */
641 extern void glutRemoveMenuItem(int arg);
642 void WINAPI wine_glutRemoveMenuItem(int arg)
643 {
644    glutRemoveMenuItem(arg);
645 }
646
647 /********************************************
648  *      glutRemoveOverlay (glut32.@)
649  */
650 extern void glutRemoveOverlay(void);
651 void WINAPI wine_glutRemoveOverlay(void)
652 {
653    glutRemoveOverlay();
654 }
655
656 /********************************************
657  *      glutReportErrors (glut32.@)
658  */
659 extern void glutReportErrors(void);
660 void WINAPI wine_glutReportErrors(void)
661 {
662    glutReportErrors();
663 }
664
665 /********************************************
666  *      glutReshapeFunc (glut32.@)
667  */
668 extern void glutReshapeFunc(void *arg);
669 void WINAPI wine_glutReshapeFunc(void *arg)
670 {
671    glutReshapeFunc(arg);
672 }
673
674 /********************************************
675  *      glutReshapeWindow (glut32.@)
676  */
677 extern void glutReshapeWindow(int arg1, int arg2);
678 void WINAPI wine_glutReshapeWindow(int arg1, int arg2)
679 {
680    glutReshapeWindow(arg1, arg2);
681 }
682
683 /********************************************
684  *      glutSetColor (glut32.@)
685  */
686 extern void glutSetColor(float arg1, float arg2, float arg3);
687 void WINAPI wine_glutSetColor(float arg1, float arg2, float arg3)
688 {
689    glutSetColor(arg1, arg2, arg3);
690 }
691
692 /********************************************
693  *      glutSetCursor (glut32.@)
694  */
695 extern void glutSetCursor(int arg);
696 void WINAPI wine_glutSetCursor(int arg)
697 {
698    glutSetCursor(arg);
699 }
700
701 /********************************************
702  *      glutSetIconTitle (glut32.@)
703  */
704 extern void glutSetIconTitle(void *arg);
705 void WINAPI wine_glutSetIconTitle(void *arg)
706 {
707    glutSetIconTitle(arg);
708 }
709
710 /********************************************
711  *      glutSetKeyRepeat (glut32.@)
712  */
713 extern void glutSetKeyRepeat(int arg);
714 void WINAPI wine_glutSetKeyRepeat(int arg)
715 {
716    glutSetKeyRepeat(arg);
717 }
718
719 /********************************************
720  *      glutSetMenu (glut32.@)
721  */
722 extern void glutSetMenu(int arg);
723 void WINAPI wine_glutSetMenu(int arg)
724 {
725    glutSetMenu(arg);
726 }
727
728 /********************************************
729  *      glutSetupVideoResizing (glut32.@)
730  */
731 extern void glutSetupVideoResizing(void);
732 void WINAPI wine_glutSetupVideoResizing(void)
733 {
734 /*   glutSetupVideoResizing(); */
735 }
736
737 /********************************************
738  *      glutSetWindow (glut32.@)
739  */
740 extern void glutSetWindow(int arg);
741 void WINAPI wine_glutSetWindow(int arg)
742 {
743    glutSetWindow(arg);
744 }
745
746 /********************************************
747  *      glutSetWindowTitle (glut32.@)
748  */
749 extern void glutSetWindowTitle(void *arg);
750 void WINAPI wine_glutSetWindowTitle(void *arg)
751 {
752    glutSetWindowTitle(arg);
753 }
754
755 /********************************************
756  *      glutShowOverlay (glut32.@)
757  */
758 extern void glutShowOverlay(void);
759 void WINAPI wine_glutShowOverlay(void)
760 {
761    glutShowOverlay();
762 }
763
764 /********************************************
765  *      glutShowWindow (glut32.@)
766  */
767 extern void glutShowWindow(void);
768 void WINAPI wine_glutShowWindow(void)
769 {
770    glutShowWindow();
771 }
772
773 /*********************************************
774  * glutSolidCone (glut32.@)
775  */
776 extern void glutSolidCone(double arg1, double arg2, int arg3, int arg4);
777 void WINAPI wine_glutSolidCone(double arg1, double arg2, int arg3, int arg4)
778 {
779    glutSolidCone(arg1, arg2, arg3, arg4);
780 }
781
782 /**********************************************
783  *      glutSolidCube (glut32.@)
784  */
785 extern void glutSolidCube(double arg);
786 void WINAPI wine_glutSolidCube(double arg)
787 {
788    glutSolidCube(arg);
789 }
790
791 /**********************************************
792  *      glutSolidDodecahedron (glut32.@)
793  */
794 extern void glutSolidDodecahedron(void);
795 void WINAPI wine_glutSolidDodecahedron(void)
796 {
797    glutSolidDodecahedron();
798 }
799
800 /**********************************************
801  *      glutSolidIcosahedron (glut32.@)
802  */
803 extern void glutSolidIcosahedron(void);
804 void WINAPI wine_glutSolidIcosahedron(void)
805 {
806    glutSolidIcosahedron();
807 }
808
809 /**********************************************
810  *      glutSolidOctahedron (glut32.@)
811  */
812 extern void glutSolidOctahedron(void);
813 void WINAPI wine_glutSolidOctahedron(void)
814 {
815    glutSolidOctahedron();
816 }
817
818 /**********************************************
819  *      glutSolidSphere (glut32.@)
820  */
821 extern void glutSolidSphere(double arg1, int arg2, int arg3);
822 void WINAPI wine_glutSolidSphere(double arg1, int arg2, int arg3)
823 {
824    glutSolidSphere(arg1, arg2, arg3);
825 }
826
827 /**********************************************
828  *      glutSolidTeapot (glut32.@)
829  */
830 extern void glutSolidTeapot(double arg);
831 void WINAPI wine_glutSolidTeapot(double arg)
832 {
833    glutSolidTeapot(arg);
834 }
835
836 /**********************************************
837  *      glutSolidTetrahedron (glut32.@)
838  */
839 extern void glutSolidTetrahedron(void);
840 void WINAPI wine_glutSolidTetrahedron(void)
841 {
842    glutSolidTetrahedron();
843 }
844
845 /**********************************************
846  *      glutSolidTetrahedron (glut32.@)
847  */
848 extern void glutSolidTorus(double arg1, double arg2,int arg3, int arg4);
849 void WINAPI wine_glutSolidTorus(double arg1, double arg2,int arg3, int arg4)
850 {
851    glutSolidTorus(arg1, arg2, arg3, arg4);
852 }
853
854 /**********************************************
855  *      glutSpaceballButtonFunc (glut32.@)
856  */
857 extern void glutSpaceballButtonFunc(void *arg);
858 void WINAPI wine_glutSpaceballButtonFunc(void *arg)
859 {
860    glutSpaceballButtonFunc(arg);
861 }
862
863 /**********************************************
864  *      glutSpaceballMotionFunc (glut32.@)
865  */
866 extern void glutSpaceballMotionFunc(void *arg);
867 void WINAPI wine_glutSpaceballMotionFunc(void *arg)
868 {
869    glutSpaceballMotionFunc(arg);
870 }
871
872 /**********************************************
873  *      glutSpaceballRotateFunc (glut32.@)
874  */
875 extern void glutSpaceballRotateFunc(void *arg);
876 void WINAPI wine_glutSpaceballRotateFunc(void *arg)
877 {
878    glutSpaceballRotateFunc(arg);
879 }
880
881 /**********************************************
882  *      glutSpecialFunc (glut32.@)
883  */
884 extern void glutSpecialFunc(void *arg);
885 void WINAPI wine_glutSpecialFunc(void *arg)
886 {
887    glutSpecialFunc(arg);
888 }
889
890 /**********************************************
891  *      glutSpecialUpFunc (glut32.@)
892  */
893 extern void glutSpecialUpFunc(void *arg);
894 void WINAPI wine_glutSpecialUpFunc(void *arg)
895 {
896    glutSpecialUpFunc(arg);
897 }
898
899 /**********************************************
900  *      glutStopVideoResizing (glut32.@)
901  */
902 extern void glutStopVideoResizing(void);
903 void WINAPI wine_glutStopVideoResizing(void)
904 {
905    glutStopVideoResizing();
906 }
907
908 /**********************************************
909  *      glutStrokeCharacter (glut32.@)
910  */
911 extern void glutStrokeCharacter(void *arg1, int arg2);
912 void WINAPI wine_glutStrokeCharacter(void *arg1, int arg2)
913 {
914    glutStrokeCharacter(arg1, arg2);
915 }
916
917 /**************************************************
918  *      glutSwapBuffers (glut32.@)
919  */
920 extern void glutSwapBuffers(void);
921 void WINAPI wine_glutSwapBuffers(void)
922 {
923    glutSwapBuffers();
924 }
925
926 /**********************************************
927  *      glutTabletButtonFunc (glut32.@)
928  */
929 extern void glutTabletButtonFunc(void *arg);
930 void WINAPI wine_glutTabletButtonFunc(void *arg)
931 {
932    glutTabletButtonFunc(arg);
933 }
934
935 /**********************************************
936  *      glutTabletMotionFunc (glut32.@)
937  */
938 extern void glutTabletMotionFunc(void *arg);
939 void WINAPI wine_glutTabletMotionFunc(void *arg)
940 {
941    glutTabletMotionFunc(arg);
942 }
943
944 /**********************************************
945  *      glutTimerFunc (glut32.@)
946  */
947 extern void glutTimerFunc(int arg1, void *arg2, int arg3);
948 void WINAPI wine_glutTimerFunc(int arg1, void *arg2, int arg3)
949 {
950    glutTimerFunc(arg1, arg2, arg3);
951 }
952
953 /**********************************************
954  *      glutUseLayer (glut32.@)
955  */
956 extern void glutUseLayer(int arg);
957 void WINAPI wine_glutUseLayer(int arg)
958 {
959    glutUseLayer(arg);
960 }
961
962 /**********************************************
963  *      glutVideoPan (glut32.@)
964  */
965 extern void glutVideoPan(int arg1, int arg2, int arg3, int arg4);
966 void WINAPI wine_glutVideoPan(int arg1, int arg2, int arg3, int arg4)
967 {
968    glutVideoPan(arg1, arg2, arg3, arg4);
969 }
970
971 /**********************************************
972  *      glutVideoResize (glut32.@)
973  */
974 extern void glutVideoResize(int arg1, int arg2, int arg3, int arg4);
975 void WINAPI wine_glutVideoResize(int arg1, int arg2, int arg3, int arg4)
976 {
977    glutVideoResize(arg1, arg2, arg3, arg4);
978 }
979
980 /**********************************************
981  *      glutVisibilityFunc (glut32.@)
982  */
983 extern void glutVisibilityFunc(void *arg);
984 void WINAPI wine_glutVisibilityFunc(void *arg)
985 {
986    glutVisibilityFunc(arg);
987 }
988
989 /**********************************************
990  *      glutWarpPointer (glut32.@)
991  */
992 extern void glutWarpPointer(int arg1, int arg2);
993 void WINAPI wine_glutWarpPointer(int arg1, int arg2)
994 {
995    glutWarpPointer(arg1, arg2);
996 }
997
998 /**********************************************
999  *      glutWindowStatusFunc (glut32.@)
1000  */
1001 extern void glutWindowStatusFunc(void *arg);
1002 void WINAPI wine_glutWindowStatusFunc(void *arg)
1003 {
1004    glutWindowStatusFunc(arg);
1005 }
1006
1007 /**********************************************
1008  *      glutWireCone (glut32.@)
1009  */
1010 extern void glutWireCone(double arg1, double arg2, int arg3, int arg4);
1011 void WINAPI wine_glutWireCone(double arg1, double arg2, int arg3,int arg4)
1012 {
1013    glutWireCone(arg1, arg2, arg3, arg4);
1014 }
1015
1016 /**********************************************
1017  *      glutWireCube (glut32.@)
1018  */
1019 extern void glutWireCube(double arg);
1020 void WINAPI wine_glutWireCube(double arg)
1021 {
1022    glutWireCube(arg);
1023 }
1024
1025 /**********************************************
1026  *      glutWireDodecahedron (glut32.@)
1027  */
1028 extern void glutWireDodecahedron(void);
1029 void WINAPI wine_glutWireDodecahedron(void)
1030 {
1031    glutWireDodecahedron();
1032 }
1033
1034 /**********************************************
1035  *      glutWireIcosahedron (glut32.@)
1036  */
1037 extern void glutWireIcosahedron(void);
1038 void WINAPI wine_glutWireIcosahedron(void)
1039 {
1040    glutWireIcosahedron();
1041 }
1042
1043 /**********************************************
1044  *      glutWireOctahedron (glut32.@)
1045  */
1046 extern void glutWireOctahedron(void);
1047 void WINAPI wine_glutWireOctahedron(void)
1048 {
1049    glutWireOctahedron();
1050 }
1051
1052 /**********************************************
1053  *      glutWireSphere (glut32.@)
1054  */
1055 extern void glutWireSphere(double arg1, int arg2, int arg3);
1056 void WINAPI wine_glutWireSphere(double arg1, int arg2, int arg3)
1057 {
1058    glutWireSphere(arg1, arg2, arg3);
1059 }
1060
1061 /**********************************************
1062  *      glutWireTeapot (glut32.@)
1063  */
1064 extern void glutWireTeapot(double arg);
1065 void WINAPI wine_glutWireTeapot(double arg)
1066 {
1067    glutWireTeapot(arg);
1068 }
1069
1070 /**********************************************
1071  *     glutWireTetrahedron (glut32.@)
1072  */
1073 extern void glutWireTetrahedron(void);
1074 void WINAPI wine_glutWireTetrahedron(void)
1075 {
1076    glutWireTetrahedron();
1077 }
1078
1079 /***********************************************
1080  *      glutWireTorus (glut32.@)
1081  */
1082 extern void glutWireTorus(double arg1, double arg2, int arg3, int arg4);
1083 void WINAPI wine_glutWireTorus(double arg1, double arg2, int arg3, int arg4)
1084 {
1085    glutWireTorus(arg1, arg2, arg3, arg4);
1086 }