git.oblomov.eu Git - wine/blob - 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 }