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