1087 lines
26 KiB
C
1087 lines
26 KiB
C
/*
|
|
* Copyright 2003 Jacek Caban
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "windef.h"
|
|
|
|
static void (*__glutExitFunc)(int ret) = 0;
|
|
|
|
/***************************************************
|
|
* DllMain [glut32.init]
|
|
*/
|
|
BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
|
|
{
|
|
if(fdwReason == DLL_PROCESS_DETACH) {
|
|
if(__glutExitFunc)
|
|
__glutExitFunc(0);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/****************************************************
|
|
* glutGetColor (glut32.@)
|
|
*/
|
|
extern float glutGetColor(int arg1, int arg2);
|
|
float WINAPI wine_glutGetColor(int arg1, int arg2)
|
|
{
|
|
return glutGetColor(arg1, arg2);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutBitmapLength (glut32.@)
|
|
*/
|
|
extern int glutBitmapLength(void *arg1, void *arg2);
|
|
int WINAPI wine_glutBitmapLength(void *arg1, void *arg2)
|
|
{
|
|
return glutBitmapLength(arg1, arg2);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutBitmapWith (glut32.@)
|
|
*/
|
|
extern int glutBitmapWidth(void *arg1, int arg2);
|
|
int WINAPI wine_glutBitmapWidth(void *arg1, int arg2)
|
|
{
|
|
return glutBitmapWidth(arg1, arg2);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutCreateMenu (glut32.@)
|
|
*/
|
|
extern int glutCreateMenu(void *arg);
|
|
int WINAPI wine_glutCreateMenu(void *arg)
|
|
{
|
|
return glutCreateMenu(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* __glutCreateMenuWithExit (glut32.@)
|
|
*/
|
|
int WINAPI wine___glutCreateMenuWithExit(void *arg1, void (*exitfunc)(int))
|
|
{
|
|
__glutExitFunc = exitfunc;
|
|
return glutCreateMenu(arg1);
|
|
}
|
|
|
|
/*****************************************************
|
|
* glutCreateSubWindow (glut32.@)
|
|
*/
|
|
extern int glutCreateSubWindow(int arg1, int arg2, int arg3, int arg4, int arg5);
|
|
int WINAPI wine_glutCreateSubWindow(int arg1, int arg2, int arg3, int arg4, int arg5)
|
|
{
|
|
return glutCreateSubWindow(arg1, arg2, arg3, arg4, arg5);
|
|
}
|
|
|
|
/*****************************************************
|
|
* glutCreateWindow (glut32.@)
|
|
*/
|
|
extern int glutCreateWindow(void *arg);
|
|
int WINAPI wine_glutCreateWindow(void *arg)
|
|
{
|
|
return glutCreateWindow(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* __glutCreateWindowWithExit (glut32.@)
|
|
*/
|
|
int WINAPI wine___glutCreateWindowWithExit(void *arg, void (*exitfunc)(int))
|
|
{
|
|
__glutExitFunc = exitfunc;
|
|
return glutCreateWindow(arg);
|
|
}
|
|
|
|
/*****************************************************
|
|
* glutDeviceGet (glut32.@)
|
|
*/
|
|
extern int glutDeviceGet(int arg);
|
|
int WINAPI wine_glutDeviceGet(int arg)
|
|
{
|
|
return glutDeviceGet(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutEnterGameMode (glut32.@)
|
|
*/
|
|
extern int glutEnterGameMode(void);
|
|
int WINAPI wine_glutEnterGameMode(void)
|
|
{
|
|
return glutEnterGameMode();
|
|
}
|
|
|
|
/****************************************************
|
|
* glutExtensionSupported (glut32.@)
|
|
*/
|
|
extern int glutExtensionSupported(void *arg);
|
|
int WINAPI wine_glutExtensionSupported(void *arg)
|
|
{
|
|
return glutExtensionSupported(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutGameModeGet (glut32.@)
|
|
*/
|
|
extern int glutGameModeGet(int arg);
|
|
int WINAPI wine_glutGameModeGet(int arg)
|
|
{
|
|
return glutGameModeGet(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutGetMenu (glut32.@)
|
|
*/
|
|
extern int glutGetMenu(void);
|
|
int WINAPI wine_glutGetMenu(void)
|
|
{
|
|
return wine_glutGetMenu();
|
|
}
|
|
|
|
/****************************************************
|
|
* glutGetModifiers (glut32.@)
|
|
*/
|
|
extern int glutGetModifiers(void);
|
|
int WINAPI wine_glutGetModifiers(void)
|
|
{
|
|
return glutGetModifiers();
|
|
}
|
|
|
|
/****************************************************
|
|
* glutGet (glut32.@)
|
|
*/
|
|
extern int glutGet(int arg);
|
|
int WINAPI wine_glutGet(int arg)
|
|
{
|
|
return glutGet(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutGetWindow (glut32.@)
|
|
*/
|
|
extern int glutGetWindow(void);
|
|
int WINAPI wine_glutGetWindow(void)
|
|
{
|
|
return glutGetWindow();
|
|
}
|
|
|
|
/****************************************************
|
|
* glutLayerGet (glut32.@)
|
|
*/
|
|
extern int glutLayerGet(int arg);
|
|
int WINAPI wine_glutLayerGet(int arg)
|
|
{
|
|
return glutLayerGet(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutStrokeLength (glut32.@)
|
|
*/
|
|
extern int glutStrokeLength(void *arg1, void* arg2);
|
|
int WINAPI wine_glutStrokeLength(void *arg1, void *arg2)
|
|
{
|
|
return glutStrokeLength(arg1, arg2);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutStrokeWidth (glut32.@)
|
|
*/
|
|
extern int glutStrokeWidth(void *arg1, int arg2);
|
|
int WINAPI wine_glutStrokeWidth(void *arg1, int arg2)
|
|
{
|
|
return glutStrokeWidth(arg1, arg2);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutVideoResizeGet (glut32.@)
|
|
*/
|
|
extern int glutVideoResizeGet(int arg);
|
|
int WINAPI wine_glutVideoResizeGet(int arg)
|
|
{
|
|
return glutVideoResizeGet(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutAddMenuEntry (glut32.@)
|
|
*/
|
|
extern void glutAddMenuEntry(void *arg1, int arg2);
|
|
void WINAPI wine_glutAddMenuEntry(void *arg1, int arg2)
|
|
{
|
|
glutAddMenuEntry(arg1, arg2);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutAddSubMenu (glut32.@)
|
|
*/
|
|
extern void glutAddSubMenu(void *arg1, int arg2);
|
|
void WINAPI wine_glutAddSubMenu(void *arg1, int arg2)
|
|
{
|
|
glutAddSubMenu(arg1, arg2);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutAttachMenu (glut32.@)
|
|
*/
|
|
extern void glutAttachMenu(int arg);
|
|
void WINAPI wine_glutAttachMenu(int arg)
|
|
{
|
|
glutAttachMenu(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutBitmapCharacter (glut32.@)
|
|
*/
|
|
extern void glutBitmapCharacter(void *arg1, int arg2);
|
|
void WINAPI wine_glutBitmapCharacter(void *arg1, int arg2)
|
|
{
|
|
glutBitmapCharacter(arg1, arg2);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutButtonBoxFunc (glut32.@)
|
|
*/
|
|
extern void glutButtonBoxFunc(void *arg);
|
|
void WINAPI wine_glutButtonBoxFunc(void *arg)
|
|
{
|
|
glutButtonBoxFunc(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutChangeToMenuEntry (glut32.@)
|
|
*/
|
|
extern void glutChangeToMenuEntry(int arg1, void *arg2, int arg3);
|
|
void WINAPI wine_glutChangeToMenuEntry(int arg1, void *arg2, int arg3)
|
|
{
|
|
glutChangeToMenuEntry(arg1, arg2, arg3);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutChangeToSubMenu (glut32.@)
|
|
*/
|
|
extern void glutChangeToSubMenu(int arg1, void *arg2, int arg3);
|
|
void WINAPI wine_glutChangeToSubMenu(int arg1, void *arg2, int arg3)
|
|
{
|
|
glutChangeToSubMenu(arg1, arg2, arg3);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutCopyColormap (glut32.@)
|
|
*/
|
|
extern void glutCopyColormap(int arg);
|
|
void WINAPI wine_glutCopyColormap(int arg)
|
|
{
|
|
glutCopyColormap(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutDestroyMenu (glut32.@)
|
|
*/
|
|
extern void glutDestroyMenu(int arg);
|
|
void WINAPI wine_glutDestroyMenu(int arg)
|
|
{
|
|
glutDestroyMenu(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutDestroyWindow (glut32.@)
|
|
*/
|
|
extern void glutDestroyWindow(int arg);
|
|
void WINAPI wine_glutDestroyWindow(int arg)
|
|
{
|
|
glutDestroyWindow(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutDetachMenu (glut32.@)
|
|
*/
|
|
extern void glutDetachMenu(int arg);
|
|
void WINAPI wine_glutDetachMenu(int arg)
|
|
{
|
|
glutDetachMenu(arg);
|
|
}
|
|
|
|
/****************************************************
|
|
* glutDialsFunc (glut32.@)
|
|
*/
|
|
extern void glutDialsFunc(void *arg);
|
|
void WINAPI wine_glutDialsFunc(void *arg)
|
|
{
|
|
glutDialsFunc(arg);
|
|
}
|
|
|
|
/*******************************************************
|
|
* glutDisplayFunc (glut32.@)
|
|
*/
|
|
extern void glutDisplayFunc(void *arg);
|
|
void WINAPI wine_glutDisplayFunc(void *arg)
|
|
{
|
|
glutDisplayFunc(arg);
|
|
}
|
|
|
|
/*******************************************************
|
|
* glutEntryFunc (glut32.@)
|
|
*/
|
|
extern void glutEntryFunc(void *arg);
|
|
void WINAPI wine_glutEntryFunc(void *arg)
|
|
{
|
|
glutEntryFunc(arg);
|
|
}
|
|
|
|
/*******************************************************
|
|
* glutEstablishOverlay (glut32.@)
|
|
*/
|
|
extern void glutEstablishOverlay(void);
|
|
void WINAPI wine_glutEstablishOverlay(void)
|
|
{
|
|
glutEstablishOverlay();
|
|
}
|
|
|
|
/*******************************************************
|
|
* glutForceJoystickFunc (glut32.@)
|
|
*/
|
|
extern void glutForceJoystickFunc(void);
|
|
void WINAPI wine_glutForceJoystickFunc(void)
|
|
{
|
|
glutForceJoystickFunc();
|
|
}
|
|
|
|
/*******************************************************
|
|
* glutFullScreen (glut32.@)
|
|
*/
|
|
extern void glutFullScreen(void);
|
|
void WINAPI wine_glutFullScreen(void)
|
|
{
|
|
glutFullScreen();
|
|
}
|
|
|
|
/*******************************************************
|
|
* glutGameModeString (glut32.@)
|
|
*/
|
|
extern void glutGameModeString(void *arg);
|
|
void WINAPI wine_glutGameModeString(void *arg)
|
|
{
|
|
glutGameModeString(arg);
|
|
}
|
|
|
|
/*******************************************************
|
|
* glutHideOverlay (glut32.@)
|
|
*/
|
|
extern void glutHideOverlay(void);
|
|
void WINAPI wine_glutHideOverlay(void)
|
|
{
|
|
glutHideOverlay();
|
|
}
|
|
|
|
/*******************************************************
|
|
* glutHideWindow (glut32.@)
|
|
*/
|
|
extern void glutHideWindow(void);
|
|
void WINAPI wine_glutHideWindow(void)
|
|
{
|
|
glutHideWindow();
|
|
}
|
|
|
|
/*******************************************************
|
|
* glutIconifyWindow (glut32.@)
|
|
*/
|
|
extern void glutIconifyWindow(void);
|
|
void WINAPI wine_glutIconifyWindow(void)
|
|
{
|
|
glutIconifyWindow();
|
|
}
|
|
|
|
/*********************************************
|
|
* glutIdleFunc (glut32.@)
|
|
*/
|
|
extern void glutIdleFunc(void *arg);
|
|
void WINAPI wine_glutIdleFunc(void *arg)
|
|
{
|
|
glutIdleFunc(arg);
|
|
}
|
|
|
|
/*********************************************
|
|
* glutIgnoreKeyRepeat (glut32.@)
|
|
*/
|
|
extern void glutIgnoreKeyRepeat(int arg);
|
|
void WINAPI wine_glutIgnoreKeyRepeat(int arg)
|
|
{
|
|
glutIgnoreKeyRepeat(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutInitDisplayMode (glut32.@)
|
|
*/
|
|
extern void glutInitDisplayMode(unsigned int arg);
|
|
void WINAPI wine_glutInitDisplayMode(unsigned int arg)
|
|
{
|
|
glutInitDisplayMode(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutInitDisplayString (glut32.@)
|
|
*/
|
|
extern void glutInitDisplayString(void *arg);
|
|
void WINAPI wine_glutInitDisplayString(void *arg)
|
|
{
|
|
glutInitDisplayString(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutInit (glut32.@)
|
|
*/
|
|
extern void glutInit(void *arg1, void *arg2);
|
|
void WINAPI wine_glutInit(void *arg1, void **arg2)
|
|
{
|
|
glutInit(arg1, arg2);
|
|
}
|
|
|
|
/**********************************************
|
|
* __glutInitWithExit (glut32.@)
|
|
*/
|
|
void WINAPI wine___glutInitWithExit(void *arg1, void *arg2, void (*exitfunc)(int))
|
|
{
|
|
__glutExitFunc = exitfunc;
|
|
glutInit(arg1, arg2);
|
|
}
|
|
|
|
/***********************************************
|
|
* glutInitWindowPosition (glut32.@)
|
|
*/
|
|
extern void glutInitWindowPosition(int arg1, int arg2);
|
|
void WINAPI wine_glutInitWindowPosition(int arg1, int arg2)
|
|
{
|
|
glutInitWindowPosition(arg1, arg2);
|
|
}
|
|
|
|
/***********************************************
|
|
* glutInitWindowSize (glut32.@)
|
|
*/
|
|
extern void glutInitWindowSize(int arg1, int arg2);
|
|
void WINAPI wine_glutInitWindowSize(int arg1, int arg2)
|
|
{
|
|
glutInitWindowSize(arg1, arg2);
|
|
}
|
|
|
|
/***********************************************
|
|
* glutJoystickFunc (glut32.@)
|
|
*/
|
|
extern void glutJoystickFunc(void *arg1, int arg2);
|
|
void WINAPI wine_glutJoystickFunc(void *arg1, int arg2)
|
|
{
|
|
glutJoystickFunc(arg1, arg2);
|
|
}
|
|
|
|
/***********************************************
|
|
* glutKeyboardFunc (glut32.@)
|
|
*/
|
|
extern void glutKeyboardFunc(void *arg);
|
|
void WINAPI wine_glutKeyboardFunc(void *arg)
|
|
{
|
|
glutKeyboardFunc(arg);
|
|
}
|
|
|
|
/***********************************************
|
|
* glutKeyboardUpFunc (glut32.@)
|
|
*/
|
|
extern void glutKeyboardUpFunc(void *arg);
|
|
void WINAPI wine_glutKeyboardUpFunc(void *arg)
|
|
{
|
|
glutKeyboardUpFunc(arg);
|
|
}
|
|
|
|
/***********************************************
|
|
* glutLeaveGameMode (glut32.@)
|
|
*/
|
|
extern void glutLeaveGameMode(void);
|
|
void WINAPI wine_glutLeaveGameMode(void)
|
|
{
|
|
glutLeaveGameMode();
|
|
}
|
|
|
|
/***********************************************
|
|
* glutMainLoop (glut32.@)
|
|
*/
|
|
extern void glutMainLoop(void);
|
|
void WINAPI wine_glutMainLoop(void)
|
|
{
|
|
glutMainLoop();
|
|
}
|
|
|
|
/***********************************************
|
|
* glutMenuStateFunc(glut32.@)
|
|
*/
|
|
extern void glutMenuStateFunc(void *arg);
|
|
void WINAPI wine_glutMenuStateFunc(void *arg)
|
|
{
|
|
glutMenuStateFunc(arg);
|
|
}
|
|
|
|
/***********************************************
|
|
* glutMenuStatusFunc (glut32.@)
|
|
*/
|
|
extern void glutMenuStatusFunc(void *arg);
|
|
void WINAPI wine_glutMenuStatusFunc(void *arg)
|
|
{
|
|
glutMenuStatusFunc(arg);
|
|
}
|
|
|
|
/***********************************************
|
|
* glutMotionFunc (glut32.@)
|
|
*/
|
|
extern void glutMotionFunc(void *arg);
|
|
void WINAPI wine_glutMotionFunc(void *arg)
|
|
{
|
|
glutMotionFunc(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutMouseFunc (glut32.@)
|
|
*/
|
|
extern void glutMouseFunc(void *arg);
|
|
void WINAPI wine_glutMouseFunc(void *arg)
|
|
{
|
|
glutMouseFunc(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutOverlayDisplayFunc (glut32.@)
|
|
*/
|
|
extern void glutOverlayDisplayFunc(void *arg);
|
|
void WINAPI wine_glutOverlayDisplayFunc(void *arg)
|
|
{
|
|
glutOverlayDisplayFunc(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutPassiveMotionFunc (glut32.@)
|
|
*/
|
|
extern void glutPassiveMotionFunc(void *arg);
|
|
void WINAPI wine_glutPassiveMotionFunc(void *arg)
|
|
{
|
|
glutPassiveMotionFunc(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutPopWindow (glut32.@)
|
|
*/
|
|
extern void glutPopWindow(void);
|
|
void WINAPI wine_glutPopWindow(void)
|
|
{
|
|
glutPopWindow();
|
|
}
|
|
|
|
/********************************************
|
|
* glutPositionWindow (glut32.@)
|
|
*/
|
|
extern void glutPositionWindow(int arg1, int arg2);
|
|
void WINAPI wine_glutPositionWindow(int arg1, int arg2)
|
|
{
|
|
glutPositionWindow(arg1, arg2);
|
|
}
|
|
|
|
/********************************************
|
|
* glutPostOverlayRedisplay (glut32.@)
|
|
*/
|
|
extern void glutPostOverlayRedisplay(void);
|
|
void WINAPI wine_glutPostOverlayRedisplay(void)
|
|
{
|
|
glutPostOverlayRedisplay();
|
|
}
|
|
|
|
/********************************************
|
|
* glutPostRedisplay (glut32.@)
|
|
*/
|
|
extern void glutPostRedisplay(void);
|
|
void WINAPI wine_glutPostRedisplay(void)
|
|
{
|
|
glutPostRedisplay();
|
|
}
|
|
|
|
/********************************************
|
|
* glutPostWindowOverlayRedisplay (glut32.@)
|
|
*/
|
|
extern void glutPostWindowOverlayRedisplay(int arg);
|
|
void WINAPI wine_glutPostWindowOverlayRedisplay(int arg)
|
|
{
|
|
glutPostWindowOverlayRedisplay(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutPostWindowRedisplay (glut32.@)
|
|
*/
|
|
extern void glutPostWindowRedisplay(int arg);
|
|
void WINAPI wine_glutPostWindowRedisplay(int arg)
|
|
{
|
|
glutPostWindowRedisplay(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutPushWindow (glut32.@)
|
|
*/
|
|
extern void glutPushWindow(void);
|
|
void WINAPI wine_glutPushWindow(void)
|
|
{
|
|
glutPushWindow();
|
|
}
|
|
|
|
/********************************************
|
|
* glutRemoveMenuItem (glut32.@)
|
|
*/
|
|
extern void glutRemoveMenuItem(int arg);
|
|
void WINAPI wine_glutRemoveMenuItem(int arg)
|
|
{
|
|
glutRemoveMenuItem(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutRemoveOverlay (glut32.@)
|
|
*/
|
|
extern void glutRemoveOverlay(void);
|
|
void WINAPI wine_glutRemoveOverlay(void)
|
|
{
|
|
glutRemoveOverlay();
|
|
}
|
|
|
|
/********************************************
|
|
* glutReportErrors (glut32.@)
|
|
*/
|
|
extern void glutReportErrors(void);
|
|
void WINAPI wine_glutReportErrors(void)
|
|
{
|
|
glutReportErrors();
|
|
}
|
|
|
|
/********************************************
|
|
* glutReshapeFunc (glut32.@)
|
|
*/
|
|
extern void glutReshapeFunc(void *arg);
|
|
void WINAPI wine_glutReshapeFunc(void *arg)
|
|
{
|
|
glutReshapeFunc(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutReshapeWindow (glut32.@)
|
|
*/
|
|
extern void glutReshapeWindow(int arg1, int arg2);
|
|
void WINAPI wine_glutReshapeWindow(int arg1, int arg2)
|
|
{
|
|
glutReshapeWindow(arg1, arg2);
|
|
}
|
|
|
|
/********************************************
|
|
* glutSetColor (glut32.@)
|
|
*/
|
|
extern void glutSetColor(float arg1, float arg2, float arg3);
|
|
void WINAPI wine_glutSetColor(float arg1, float arg2, float arg3)
|
|
{
|
|
glutSetColor(arg1, arg2, arg3);
|
|
}
|
|
|
|
/********************************************
|
|
* glutSetCursor (glut32.@)
|
|
*/
|
|
extern void glutSetCursor(int arg);
|
|
void WINAPI wine_glutSetCursor(int arg)
|
|
{
|
|
glutSetCursor(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutSetIconTitle (glut32.@)
|
|
*/
|
|
extern void glutSetIconTitle(void *arg);
|
|
void WINAPI wine_glutSetIconTitle(void *arg)
|
|
{
|
|
glutSetIconTitle(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutSetKeyRepeat (glut32.@)
|
|
*/
|
|
extern void glutSetKeyRepeat(int arg);
|
|
void WINAPI wine_glutSetKeyRepeat(int arg)
|
|
{
|
|
glutSetKeyRepeat(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutSetMenu (glut32.@)
|
|
*/
|
|
extern void glutSetMenu(int arg);
|
|
void WINAPI wine_glutSetMenu(int arg)
|
|
{
|
|
glutSetMenu(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutSetupVideoResizing (glut32.@)
|
|
*/
|
|
extern void glutSetupVideoResizing(void);
|
|
void WINAPI wine_glutSetupVideoResizing(void)
|
|
{
|
|
/* glutSetupVideoResizing(); */
|
|
}
|
|
|
|
/********************************************
|
|
* glutSetWindow (glut32.@)
|
|
*/
|
|
extern void glutSetWindow(int arg);
|
|
void WINAPI wine_glutSetWindow(int arg)
|
|
{
|
|
glutSetWindow(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutSetWindowTitle (glut32.@)
|
|
*/
|
|
extern void glutSetWindowTitle(void *arg);
|
|
void WINAPI wine_glutSetWindowTitle(void *arg)
|
|
{
|
|
glutSetWindowTitle(arg);
|
|
}
|
|
|
|
/********************************************
|
|
* glutShowOverlay (glut32.@)
|
|
*/
|
|
extern void glutShowOverlay(void);
|
|
void WINAPI wine_glutShowOverlay(void)
|
|
{
|
|
glutShowOverlay();
|
|
}
|
|
|
|
/********************************************
|
|
* glutShowWindow (glut32.@)
|
|
*/
|
|
extern void glutShowWindow(void);
|
|
void WINAPI wine_glutShowWindow(void)
|
|
{
|
|
glutShowWindow();
|
|
}
|
|
|
|
/*********************************************
|
|
* glutSolidCone (glut32.@)
|
|
*/
|
|
extern void glutSolidCone(double arg1, double arg2, int arg3, int arg4);
|
|
void WINAPI wine_glutSolidCone(double arg1, double arg2, int arg3, int arg4)
|
|
{
|
|
glutSolidCone(arg1, arg2, arg3, arg4);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSolidCube (glut32.@)
|
|
*/
|
|
extern void glutSolidCube(double arg);
|
|
void WINAPI wine_glutSolidCube(double arg)
|
|
{
|
|
glutSolidCube(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSolidDodecahedron (glut32.@)
|
|
*/
|
|
extern void glutSolidDodecahedron(void);
|
|
void WINAPI wine_glutSolidDodecahedron(void)
|
|
{
|
|
glutSolidDodecahedron();
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSolidIcosahedron (glut32.@)
|
|
*/
|
|
extern void glutSolidIcosahedron(void);
|
|
void WINAPI wine_glutSolidIcosahedron(void)
|
|
{
|
|
glutSolidIcosahedron();
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSolidOctahedron (glut32.@)
|
|
*/
|
|
extern void glutSolidOctahedron(void);
|
|
void WINAPI wine_glutSolidOctahedron(void)
|
|
{
|
|
glutSolidOctahedron();
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSolidSphere (glut32.@)
|
|
*/
|
|
extern void glutSolidSphere(double arg1, int arg2, int arg3);
|
|
void WINAPI wine_glutSolidSphere(double arg1, int arg2, int arg3)
|
|
{
|
|
glutSolidSphere(arg1, arg2, arg3);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSolidTeapot (glut32.@)
|
|
*/
|
|
extern void glutSolidTeapot(double arg);
|
|
void WINAPI wine_glutSolidTeapot(double arg)
|
|
{
|
|
glutSolidTeapot(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSolidTetrahedron (glut32.@)
|
|
*/
|
|
extern void glutSolidTetrahedron(void);
|
|
void WINAPI wine_glutSolidTetrahedron(void)
|
|
{
|
|
glutSolidTetrahedron();
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSolidTetrahedron (glut32.@)
|
|
*/
|
|
extern void glutSolidTorus(double arg1, double arg2,int arg3, int arg4);
|
|
void WINAPI wine_glutSolidTorus(double arg1, double arg2,int arg3, int arg4)
|
|
{
|
|
glutSolidTorus(arg1, arg2, arg3, arg4);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSpaceballButtonFunc (glut32.@)
|
|
*/
|
|
extern void glutSpaceballButtonFunc(void *arg);
|
|
void WINAPI wine_glutSpaceballButtonFunc(void *arg)
|
|
{
|
|
glutSpaceballButtonFunc(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSpaceballMotionFunc (glut32.@)
|
|
*/
|
|
extern void glutSpaceballMotionFunc(void *arg);
|
|
void WINAPI wine_glutSpaceballMotionFunc(void *arg)
|
|
{
|
|
glutSpaceballMotionFunc(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSpaceballRotateFunc (glut32.@)
|
|
*/
|
|
extern void glutSpaceballRotateFunc(void *arg);
|
|
void WINAPI wine_glutSpaceballRotateFunc(void *arg)
|
|
{
|
|
glutSpaceballRotateFunc(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSpecialFunc (glut32.@)
|
|
*/
|
|
extern void glutSpecialFunc(void *arg);
|
|
void WINAPI wine_glutSpecialFunc(void *arg)
|
|
{
|
|
glutSpecialFunc(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutSpecialUpFunc (glut32.@)
|
|
*/
|
|
extern void glutSpecialUpFunc(void *arg);
|
|
void WINAPI wine_glutSpecialUpFunc(void *arg)
|
|
{
|
|
glutSpecialUpFunc(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutStopVideoResizing (glut32.@)
|
|
*/
|
|
extern void glutStopVideoResizing(void);
|
|
void WINAPI wine_glutStopVideoResizing(void)
|
|
{
|
|
glutStopVideoResizing();
|
|
}
|
|
|
|
/**********************************************
|
|
* glutStrokeCharacter (glut32.@)
|
|
*/
|
|
extern void glutStrokeCharacter(void *arg1, int arg2);
|
|
void WINAPI wine_glutStrokeCharacter(void *arg1, int arg2)
|
|
{
|
|
glutStrokeCharacter(arg1, arg2);
|
|
}
|
|
|
|
/**************************************************
|
|
* glutSwapBuffers (glut32.@)
|
|
*/
|
|
extern void glutSwapBuffers(void);
|
|
void WINAPI wine_glutSwapBuffers(void)
|
|
{
|
|
glutSwapBuffers();
|
|
}
|
|
|
|
/**********************************************
|
|
* glutTabletButtonFunc (glut32.@)
|
|
*/
|
|
extern void glutTabletButtonFunc(void *arg);
|
|
void WINAPI wine_glutTabletButtonFunc(void *arg)
|
|
{
|
|
glutTabletButtonFunc(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutTabletMotionFunc (glut32.@)
|
|
*/
|
|
extern void glutTabletMotionFunc(void *arg);
|
|
void WINAPI wine_glutTabletMotionFunc(void *arg)
|
|
{
|
|
glutTabletMotionFunc(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutTimerFunc (glut32.@)
|
|
*/
|
|
extern void glutTimerFunc(int arg1, void *arg2, int arg3);
|
|
void WINAPI wine_glutTimerFunc(int arg1, void *arg2, int arg3)
|
|
{
|
|
glutTimerFunc(arg1, arg2, arg3);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutUseLayer (glut32.@)
|
|
*/
|
|
extern void glutUseLayer(int arg);
|
|
void WINAPI wine_glutUseLayer(int arg)
|
|
{
|
|
glutUseLayer(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutVideoPan (glut32.@)
|
|
*/
|
|
extern void glutVideoPan(int arg1, int arg2, int arg3, int arg4);
|
|
void WINAPI wine_glutVideoPan(int arg1, int arg2, int arg3, int arg4)
|
|
{
|
|
glutVideoPan(arg1, arg2, arg3, arg4);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutVideoResize (glut32.@)
|
|
*/
|
|
extern void glutVideoResize(int arg1, int arg2, int arg3, int arg4);
|
|
void WINAPI wine_glutVideoResize(int arg1, int arg2, int arg3, int arg4)
|
|
{
|
|
glutVideoResize(arg1, arg2, arg3, arg4);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutVisibilityFunc (glut32.@)
|
|
*/
|
|
extern void glutVisibilityFunc(void *arg);
|
|
void WINAPI wine_glutVisibilityFunc(void *arg)
|
|
{
|
|
glutVisibilityFunc(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutWarpPointer (glut32.@)
|
|
*/
|
|
extern void glutWarpPointer(int arg1, int arg2);
|
|
void WINAPI wine_glutWarpPointer(int arg1, int arg2)
|
|
{
|
|
glutWarpPointer(arg1, arg2);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutWindowStatusFunc (glut32.@)
|
|
*/
|
|
extern void glutWindowStatusFunc(void *arg);
|
|
void WINAPI wine_glutWindowStatusFunc(void *arg)
|
|
{
|
|
glutWindowStatusFunc(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutWireCone (glut32.@)
|
|
*/
|
|
extern void glutWireCone(double arg1, double arg2, int arg3, int arg4);
|
|
void WINAPI wine_glutWireCone(double arg1, double arg2, int arg3,int arg4)
|
|
{
|
|
glutWireCone(arg1, arg2, arg3, arg4);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutWireCube (glut32.@)
|
|
*/
|
|
extern void glutWireCube(double arg);
|
|
void WINAPI wine_glutWireCube(double arg)
|
|
{
|
|
glutWireCube(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutWireDodecahedron (glut32.@)
|
|
*/
|
|
extern void glutWireDodecahedron(void);
|
|
void WINAPI wine_glutWireDodecahedron(void)
|
|
{
|
|
glutWireDodecahedron();
|
|
}
|
|
|
|
/**********************************************
|
|
* glutWireIcosahedron (glut32.@)
|
|
*/
|
|
extern void glutWireIcosahedron(void);
|
|
void WINAPI wine_glutWireIcosahedron(void)
|
|
{
|
|
glutWireIcosahedron();
|
|
}
|
|
|
|
/**********************************************
|
|
* glutWireOctahedron (glut32.@)
|
|
*/
|
|
extern void glutWireOctahedron(void);
|
|
void WINAPI wine_glutWireOctahedron(void)
|
|
{
|
|
glutWireOctahedron();
|
|
}
|
|
|
|
/**********************************************
|
|
* glutWireSphere (glut32.@)
|
|
*/
|
|
extern void glutWireSphere(double arg1, int arg2, int arg3);
|
|
void WINAPI wine_glutWireSphere(double arg1, int arg2, int arg3)
|
|
{
|
|
glutWireSphere(arg1, arg2, arg3);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutWireTeapot (glut32.@)
|
|
*/
|
|
extern void glutWireTeapot(double arg);
|
|
void WINAPI wine_glutWireTeapot(double arg)
|
|
{
|
|
glutWireTeapot(arg);
|
|
}
|
|
|
|
/**********************************************
|
|
* glutWireTetrahedron (glut32.@)
|
|
*/
|
|
extern void glutWireTetrahedron(void);
|
|
void WINAPI wine_glutWireTetrahedron(void)
|
|
{
|
|
glutWireTetrahedron();
|
|
}
|
|
|
|
/***********************************************
|
|
* glutWireTorus (glut32.@)
|
|
*/
|
|
extern void glutWireTorus(double arg1, double arg2, int arg3, int arg4);
|
|
void WINAPI wine_glutWireTorus(double arg1, double arg2, int arg3, int arg4)
|
|
{
|
|
glutWireTorus(arg1, arg2, arg3, arg4);
|
|
}
|