#ifndef __glutint_h__ #define __glutint_h__ /* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */ /* This program is freely distributable without licensing fees and is provided without guarantee or warrantee expressed or implied. This program is -not- in the public domain. */ #if defined(__CYGWIN32__) #include #endif #if defined(_WIN32) #include "glutwin32.h" #elif !defined(__BEOS__) #ifdef __sgi #define SUPPORT_FORTRAN #endif #include #include #include #endif #include /* Non-Win32 platforms need APIENTRY defined to nothing because all the GLUT routines have the APIENTRY prefix to make Win32 happy. */ #ifndef APIENTRY #define APIENTRY #endif #ifdef __vms #if ( __VMS_VER < 70000000 ) struct timeval { __int64 val; }; extern int sys$gettim(struct timeval *); #else #include #endif #else #include #if !defined(_WIN32) #include #else #include #endif #endif #if defined(__vms) && ( __VMS_VER < 70000000 ) /* For VMS6.2 or lower : One TICK on VMS is 100 nanoseconds; 0.1 microseconds or 0.0001 milliseconds. This means that there are 0.01 ticks/ns, 10 ticks/us, 10,000 ticks/ms and 10,000,000 ticks/second. */ #define TICKS_PER_MILLISECOND 10000 #define TICKS_PER_SECOND 10000000 #define GETTIMEOFDAY(_x) (void) sys$gettim (_x); #define ADD_TIME(dest, src1, src2) { \ (dest).val = (src1).val + (src2).val; \ } #define TIMEDELTA(dest, src1, src2) { \ (dest).val = (src1).val - (src2).val; \ } #define IS_AFTER(t1, t2) ((t2).val > (t1).val) #define IS_AT_OR_AFTER(t1, t2) ((t2).val >= (t1).val) #else #if defined(SVR4) && !defined(sun) /* Sun claims SVR4, but wants 2 args. */ #define GETTIMEOFDAY(_x) gettimeofday(_x) #else #define GETTIMEOFDAY(_x) gettimeofday(_x, NULL) #endif #define ADD_TIME(dest, src1, src2) { \ if(((dest).tv_usec = \ (src1).tv_usec + (src2).tv_usec) >= 1000000) { \ (dest).tv_usec -= 1000000; \ (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1; \ } else { \ (dest).tv_sec = (src1).tv_sec + (src2).tv_sec; \ if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { \ (dest).tv_sec --;(dest).tv_usec += 1000000; \ } \ } \ } #define TIMEDELTA(dest, src1, src2) { \ if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) { \ (dest).tv_usec += 1000000; \ (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1; \ } else { \ (dest).tv_sec = (src1).tv_sec - (src2).tv_sec; \ } \ } #define IS_AFTER(t1, t2) \ (((t2).tv_sec > (t1).tv_sec) || \ (((t2).tv_sec == (t1).tv_sec) && \ ((t2).tv_usec > (t1).tv_usec))) #define IS_AT_OR_AFTER(t1, t2) \ (((t2).tv_sec > (t1).tv_sec) || \ (((t2).tv_sec == (t1).tv_sec) && \ ((t2).tv_usec >= (t1).tv_usec))) #endif #define IGNORE_IN_GAME_MODE() \ { if (__glutGameModeWindow) return; } /* BeOS doesn't need most of this file */ #ifndef __BEOS__ #define GLUT_WIND_IS_RGB(x) (((x) & GLUT_INDEX) == 0) #define GLUT_WIND_IS_INDEX(x) (((x) & GLUT_INDEX) != 0) #define GLUT_WIND_IS_SINGLE(x) (((x) & GLUT_DOUBLE) == 0) #define GLUT_WIND_IS_DOUBLE(x) (((x) & GLUT_DOUBLE) != 0) #define GLUT_WIND_HAS_ACCUM(x) (((x) & GLUT_ACCUM) != 0) #define GLUT_WIND_HAS_ALPHA(x) (((x) & GLUT_ALPHA) != 0) #define GLUT_WIND_HAS_DEPTH(x) (((x) & GLUT_DEPTH) != 0) #define GLUT_WIND_HAS_STENCIL(x) (((x) & GLUT_STENCIL) != 0) #define GLUT_WIND_IS_MULTISAMPLE(x) (((x) & GLUT_MULTISAMPLE) != 0) #define GLUT_WIND_IS_STEREO(x) (((x) & GLUT_STEREO) != 0) #define GLUT_WIND_IS_LUMINANCE(x) (((x) & GLUT_LUMINANCE) != 0) #define GLUT_MAP_WORK (1 << 0) #define GLUT_EVENT_MASK_WORK (1 << 1) #define GLUT_REDISPLAY_WORK (1 << 2) #define GLUT_CONFIGURE_WORK (1 << 3) #define GLUT_COLORMAP_WORK (1 << 4) #define GLUT_DEVICE_MASK_WORK (1 << 5) #define GLUT_FINISH_WORK (1 << 6) #define GLUT_DEBUG_WORK (1 << 7) #define GLUT_DUMMY_WORK (1 << 8) #define GLUT_FULL_SCREEN_WORK (1 << 9) #define GLUT_OVERLAY_REDISPLAY_WORK (1 << 10) #define GLUT_REPAIR_WORK (1 << 11) #define GLUT_OVERLAY_REPAIR_WORK (1 << 12) /* Frame buffer capability macros and types. */ #define RGBA 0 #define BUFFER_SIZE 1 #define DOUBLEBUFFER 2 #define STEREO 3 #define AUX_BUFFERS 4 #define RED_SIZE 5 /* Used as mask bit for "color selected". */ #define GREEN_SIZE 6 #define BLUE_SIZE 7 #define ALPHA_SIZE 8 #define DEPTH_SIZE 9 #define STENCIL_SIZE 10 #define ACCUM_RED_SIZE 11 /* Used as mask bit for "acc selected". */ #define ACCUM_GREEN_SIZE 12 #define ACCUM_BLUE_SIZE 13 #define ACCUM_ALPHA_SIZE 14 #define LEVEL 15 #define NUM_GLXCAPS (LEVEL + 1) #define XVISUAL (NUM_GLXCAPS + 0) #define TRANSPARENT (NUM_GLXCAPS + 1) #define SAMPLES (NUM_GLXCAPS + 2) #define XSTATICGRAY (NUM_GLXCAPS + 3) /* Used as mask bit for "any visual type selected". */ #define XGRAYSCALE (NUM_GLXCAPS + 4) #define XSTATICCOLOR (NUM_GLXCAPS + 5) #define XPSEUDOCOLOR (NUM_GLXCAPS + 6) #define XTRUECOLOR (NUM_GLXCAPS + 7) #define XDIRECTCOLOR (NUM_GLXCAPS + 8) #define SLOW (NUM_GLXCAPS + 9) #define CONFORMANT (NUM_GLXCAPS + 10) #define NUM_CAPS (NUM_GLXCAPS + 11) /* Frame buffer capablities that don't have a corresponding FrameBufferMode entry. These get used as mask bits. */ #define NUM (NUM_CAPS + 0) #define RGBA_MODE (NUM_CAPS + 1) #define CI_MODE (NUM_CAPS + 2) #define LUMINANCE_MODE (NUM_CAPS + 3) #define NONE 0 #define EQ 1 #define NEQ 2 #define LTE 3 #define GTE 4 #define GT 5 #define LT 6 #define MIN 7 typedef struct _Criterion { int capability; int comparison; int value; } Criterion; typedef struct _FrameBufferMode { XVisualInfo *vi; #if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig) /* fbc is non-NULL when the XVisualInfo* is not OpenGL-capable (ie, GLX_USE_GL is false), but the SGIX_fbconfig extension shows the visual's fbconfig is OpenGL-capable. The reason for this is typically an RGBA luminance fbconfig such as 16-bit StaticGray that could not be advertised as a GLX visual since StaticGray visuals are required (by the GLX specification) to be color index. The SGIX_fbconfig allows StaticGray visuals to instead advertised as fbconfigs that can provide RGBA luminance support. */ GLXFBConfigSGIX fbc; #endif int valid; int cap[NUM_CAPS]; } FrameBufferMode; /* DisplayMode capability macros for game mode. */ #define DM_WIDTH 0 /* "width" */ #define DM_HEIGHT 1 /* "height" */ #define DM_PIXEL_DEPTH 2 /* "bpp" (bits per pixel) */ #define DM_HERTZ 3 /* "hertz" */ #define DM_NUM 4 /* "num" */ #define NUM_DM_CAPS (DM_NUM+1) typedef struct _DisplayMode { #ifdef _WIN32 DEVMODE devmode; #else /* XXX The X Window System does not have a standard mechanism for display setting changes. On SGI systems, GLUT could use the XSGIvc (SGI X video control extension). Perhaps this can be done in a future release of GLUT. */ #endif int valid; int cap[NUM_DM_CAPS]; } DisplayMode; #endif /* BeOS */ /* GLUT function types */ typedef void (*GLUTdisplayCB) (void); typedef void (*GLUTreshapeCB) (int, int); typedef void (*GLUTkeyboardCB) (unsigned char, int, int); typedef void (*GLUTmouseCB) (int, int, int, int); typedef void (*GLUTmotionCB) (int, int); typedef void (*GLUTpassiveCB) (int, int); typedef void (*GLUTentryCB) (int); typedef void (*GLUTvisibilityCB) (int); typedef void (*GLUTwindowStatusCB) (int); typedef void (*GLUTidleCB) (void); typedef void (*GLUTtimerCB) (int); typedef void (*GLUTmenuStateCB) (int); /* DEPRICATED. */ typedef void (*GLUTmenuStatusCB) (int, int, int); typedef void (*GLUTselectCB) (int); typedef void (*GLUTspecialCB) (int, int, int); typedef void (*GLUTspaceMotionCB) (int, int, int); typedef void (*GLUTspaceRotateCB) (int, int, int); typedef void (*GLUTspaceButtonCB) (int, int); typedef void (*GLUTdialsCB) (int, int); typedef void (*GLUTbuttonBoxCB) (int, int); typedef void (*GLUTtabletMotionCB) (int, int); typedef void (*GLUTtabletButtonCB) (int, int, int, int); typedef void (*GLUTjoystickCB) (unsigned int buttonMask, int x, int y, int z); #ifdef SUPPORT_FORTRAN typedef void (*GLUTdisplayFCB) (void); typedef void (*GLUTreshapeFCB) (int *, int *); /* NOTE the pressed key is int, not unsigned char for Fortran! */ typedef void (*GLUTkeyboardFCB) (int *, int *, int *); typedef void (*GLUTmouseFCB) (int *, int *, int *, int *); typedef void (*GLUTmotionFCB) (int *, int *); typedef void (*GLUTpassiveFCB) (int *, int *); typedef void (*GLUTentryFCB) (int *); typedef void (*GLUTvisibilityFCB) (int *); typedef void (*GLUTwindowStatusFCB) (int *); typedef void (*GLUTidleFCB) (void); typedef void (*GLUTtimerFCB) (int *); typedef void (*GLUTmenuStateFCB) (int *); /* DEPRICATED. */ typedef void (*GLUTmenuStatusFCB) (int *, int *, int *); typedef void (*GLUTselectFCB) (int *); typedef void (*GLUTspecialFCB) (int *, int *, int *); typedef void (*GLUTspaceMotionFCB) (int *, int *, int *); typedef void (*GLUTspaceRotateFCB) (int *, int *, int *); typedef void (*GLUTspaceButtonFCB) (int *, int *); typedef void (*GLUTdialsFCB) (int *, int *); typedef void (*GLUTbuttonBoxFCB) (int *, int *); typedef void (*GLUTtabletMotionFCB) (int *, int *); typedef void (*GLUTtabletButtonFCB) (int *, int *, int *, int *); typedef void (*GLUTjoystickFCB) (unsigned int *buttonMask, int *x, int *y, int *z); #endif #ifndef __BEOS__ typedef struct _GLUTcolorcell GLUTcolorcell; struct _GLUTcolorcell { /* GLUT_RED, GLUT_GREEN, GLUT_BLUE */ GLfloat component[3]; }; typedef struct _GLUTcolormap GLUTcolormap; struct _GLUTcolormap { Visual *visual; /* visual of the colormap */ Colormap cmap; /* X colormap ID */ int refcnt; /* number of windows using colormap */ int size; /* number of cells in colormap */ int transparent; /* transparent pixel, or -1 if opaque */ GLUTcolorcell *cells; /* array of cells */ GLUTcolormap *next; /* next colormap in list */ }; typedef struct _GLUTwindow GLUTwindow; typedef struct _GLUToverlay GLUToverlay; struct _GLUTwindow { int num; /* Small integer window id (0-based). */ /* Window system related state. */ #if defined(_WIN32) int pf; /* Pixel format. */ HDC hdc; /* Window's Win32 device context. */ #endif Window win; /* X window for GLUT window */ GLXContext ctx; /* OpenGL context GLUT glut window */ XVisualInfo *vis; /* visual for window */ Bool visAlloced; /* if vis needs deallocate on destroy */ Colormap cmap; /* RGB colormap for window; None if CI */ GLUTcolormap *colormap; /* colormap; NULL if RGBA */ GLUToverlay *overlay; /* overlay; NULL if no overlay */ #if defined(_WIN32) HDC renderDc; /* Win32's device context for rendering. */ #endif Window renderWin; /* X window for rendering (might be overlay) */ GLXContext renderCtx; /* OpenGL context for rendering (might be overlay) */ /* GLUT settable or visible window state. */ int width; /* window width in pixels */ int height; /* window height in pixels */ int cursor; /* cursor name */ int visState; /* visibility state (-1 is unknown) */ int shownState; /* if window mapped */ int entryState; /* entry state (-1 is unknown) */ #define GLUT_MAX_MENUS 3 int menu[GLUT_MAX_MENUS]; /* attatched menu nums */ /* Window relationship state. */ GLUTwindow *parent; /* parent window */ GLUTwindow *children; /* list of children */ GLUTwindow *siblings; /* list of siblings */ /* Misc. non-API visible (hidden) state. */ Bool treatAsSingle; /* treat this window as single-buffered (it might be "fake" though) */ Bool forceReshape; /* force reshape before display */ #if !defined(_WIN32) Bool isDirect; /* if direct context (X11 only) */ #endif Bool usedSwapBuffers; /* if swap buffers used last display */ long eventMask; /* mask of X events selected for */ int buttonUses; /* number of button uses, ref cnt */ int tabletPos[2]; /* tablet position (-1 is invalid) */ /* Work list related state. */ unsigned int workMask; /* mask of window work to be done */ GLUTwindow *prevWorkWin; /* link list of windows to work on */ Bool desiredMapState; /* how to mapped window if on map work list */ Bool ignoreKeyRepeat; /* if window ignores autorepeat */ int desiredConfMask; /* mask of desired window configuration */ int desiredX; /* desired X location */ int desiredY; /* desired Y location */ int desiredWidth; /* desired window width */ int desiredHeight; /* desired window height */ int desiredStack; /* desired window stack */ /* Per-window callbacks. */ GLUTdisplayCB display; /* redraw */ GLUTreshapeCB reshape; /* resize (width,height) */ GLUTmouseCB mouse; /* mouse (button,state,x,y) */ GLUTmotionCB motion; /* motion (x,y) */ GLUTpassiveCB passive; /* passive motion (x,y) */ GLUTentryCB entry; /* window entry/exit (state) */ GLUTkeyboardCB keyboard; /* keyboard (ASCII,x,y) */ GLUTkeyboardCB keyboardUp; /* keyboard up (ASCII,x,y) */ GLUTwindowStatusCB windowStatus; /* window status */ GLUTvisibilityCB visibility; /* visibility */ GLUTspecialCB special; /* special key */ GLUTspecialCB specialUp; /* special up key */ GLUTbuttonBoxCB buttonBox; /* button box */ GLUTdialsCB dials; /* dials */ GLUTspaceMotionCB spaceMotion; /* Spaceball motion */ GLUTspaceRotateCB spaceRotate; /* Spaceball rotate */ GLUTspaceButtonCB spaceButton; /* Spaceball button */ GLUTtabletMotionCB tabletMotion; /* tablet motion */ GLUTtabletButtonCB tabletButton; /* tablet button */ #ifdef _WIN32 GLUTjoystickCB joystick; /* joystick */ int joyPollInterval; /* joystick polling interval */ #endif #ifdef SUPPORT_FORTRAN /* Special Fortran display unneeded since no parameters! */ GLUTreshapeFCB freshape; /* Fortran reshape */ GLUTmouseFCB fmouse; /* Fortran mouse */ GLUTmotionFCB fmotion; /* Fortran motion */ GLUTpassiveFCB fpassive; /* Fortran passive */ GLUTentryFCB fentry; /* Fortran entry */ GLUTkeyboardFCB fkeyboard; /* Fortran keyboard */ GLUTkeyboardFCB fkeyboardUp; /* Fortran keyboard up */ GLUTwindowStatusFCB fwindowStatus; /* Fortran visibility */ GLUTvisibilityFCB fvisibility; /* Fortran visibility */ GLUTspecialFCB fspecial; /* special key */ GLUTspecialFCB fspecialUp; /* special key up */ GLUTbuttonBoxFCB fbuttonBox; /* button box */ GLUTdialsFCB fdials; /* dials */ GLUTspaceMotionFCB fspaceMotion; /* Spaceball motion */ GLUTspaceRotateFCB fspaceRotate; /* Spaceball rotate */ GLUTspaceButtonFCB fspaceButton; /* Spaceball button */ GLUTtabletMotionFCB ftabletMotion; /* tablet motion */ GLUTtabletButtonFCB ftabletButton; /* tablet button */ #ifdef _WIN32 GLUTjoystickFCB fjoystick; /* joystick */ #endif #endif }; struct _GLUToverlay { #if defined(_WIN32) int pf; HDC hdc; #endif Window win; GLXContext ctx; XVisualInfo *vis; /* visual for window */ Bool visAlloced; /* if vis needs deallocate on destroy */ Colormap cmap; /* RGB colormap for window; None if CI */ GLUTcolormap *colormap; /* colormap; NULL if RGBA */ int shownState; /* if overlay window mapped */ Bool treatAsSingle; /* treat as single-buffered */ #if !defined(_WIN32) Bool isDirect; /* if direct context */ #endif int transparentPixel; /* transparent pixel value */ GLUTdisplayCB display; /* redraw */ /* Special Fortran display unneeded since no parameters! */ }; typedef struct _GLUTstale GLUTstale; struct _GLUTstale { GLUTwindow *window; Window win; GLUTstale *next; }; extern GLUTstale *__glutStaleWindowList; #define GLUT_OVERLAY_EVENT_FILTER_MASK \ (ExposureMask | \ StructureNotifyMask | \ EnterWindowMask | \ LeaveWindowMask) #define GLUT_DONT_PROPAGATE_FILTER_MASK \ (ButtonReleaseMask | \ ButtonPressMask | \ KeyPressMask | \ KeyReleaseMask | \ PointerMotionMask | \ Button1MotionMask | \ Button2MotionMask | \ Button3MotionMask) #define GLUT_HACK_STOP_PROPAGATE_MASK \ (KeyPressMask | \ KeyReleaseMask) typedef struct _GLUTmenu GLUTmenu; typedef struct _GLUTmenuItem GLUTmenuItem; struct _GLUTmenu { int id; /* small integer menu id (0-based) */ Window win; /* X window for the menu */ GLUTselectCB select; /* function of menu */ GLUTmenuItem *list; /* list of menu entries */ int num; /* number of entries */ #if !defined(_WIN32) Bool managed; /* are the InputOnly windows size validated? */ Bool searched; /* help detect menu loops */ int pixheight; /* height of menu in pixels */ int pixwidth; /* width of menu in pixels */ #endif int submenus; /* number of submenu entries */ GLUTmenuItem *highlighted; /* pointer to highlighted menu entry, NULL not highlighted */ GLUTmenu *cascade; /* currently cascading this menu */ GLUTmenuItem *anchor; /* currently anchored to this entry */ int x; /* current x origin relative to the root window */ int y; /* current y origin relative to the root window */ #ifdef SUPPORT_FORTRAN GLUTselectFCB fselect; /* function of menu */ #endif }; struct _GLUTmenuItem { Window win; /* InputOnly X window for entry */ GLUTmenu *menu; /* menu entry belongs to */ Bool isTrigger; /* is a submenu trigger? */ int value; /* value to return for selecting this entry; doubles as submenu id (0-base) if submenu trigger */ #if defined(_WIN32) UINT unique; /* unique menu item id (Win32 only) */ #endif char *label; /* __glutStrdup'ed label string */ int len; /* length of label string */ int pixwidth; /* width of X window in pixels */ GLUTmenuItem *next; /* next menu entry on list for menu */ }; typedef struct _GLUTtimer GLUTtimer; struct _GLUTtimer { GLUTtimer *next; /* list of timers */ struct timeval timeout; /* time to be called */ GLUTtimerCB func; /* timer (value) */ int value; /* return value */ #ifdef SUPPORT_FORTRAN GLUTtimerFCB ffunc; /* Fortran timer */ #endif }; typedef struct _GLUTeventParser GLUTeventParser; struct _GLUTeventParser { int (*func) (XEvent *); GLUTeventParser *next; }; /* Declarations to implement glutFullScreen support with mwm/4Dwm. */ /* The following X property format is defined in Motif 1.1's Xm/MwmUtils.h, but GLUT should not depend on that header file. Note: Motif 1.2 expanded this structure with uninteresting fields (to GLUT) so just stick with the smaller Motif 1.1 structure. */ typedef struct { #define MWM_HINTS_DECORATIONS 2 long flags; long functions; long decorations; long input_mode; } MotifWmHints; /* Make current and buffer swap macros. */ #ifdef _WIN32 #define MAKE_CURRENT_LAYER(window) \ { \ HGLRC currentContext = wglGetCurrentContext(); \ HDC currentDc = wglGetCurrentDC(); \ \ if (currentContext != window->renderCtx \ || currentDc != window->renderDc) { \ wglMakeCurrent(window->renderDc, window->renderCtx); \ } \ } #define MAKE_CURRENT_WINDOW(window) \ { \ HGLRC currentContext = wglGetCurrentContext(); \ HDC currentDc = wglGetCurrentDC(); \ \ if (currentContext != window->ctx || currentDc != window->hdc) { \ wglMakeCurrent(window->hdc, window->ctx); \ } \ } #define MAKE_CURRENT_OVERLAY(overlay) \ wglMakeCurrent(overlay->hdc, overlay->ctx) #define UNMAKE_CURRENT() \ wglMakeCurrent(NULL, NULL) #define SWAP_BUFFERS_WINDOW(window) \ SwapBuffers(window->hdc) #define SWAP_BUFFERS_LAYER(window) \ SwapBuffers(window->renderDc) #else #define MAKE_CURRENT_LAYER(window) \ glXMakeCurrent(__glutDisplay, window->renderWin, window->renderCtx) #define MAKE_CURRENT_WINDOW(window) \ glXMakeCurrent(__glutDisplay, window->win, window->ctx) #define MAKE_CURRENT_OVERLAY(overlay) \ glXMakeCurrent(__glutDisplay, overlay->win, overlay->ctx) #define UNMAKE_CURRENT() \ glXMakeCurrent(__glutDisplay, None, NULL) #define SWAP_BUFFERS_WINDOW(window) \ glXSwapBuffers(__glutDisplay, window->win) #define SWAP_BUFFERS_LAYER(window) \ glXSwapBuffers(__glutDisplay, window->renderWin) #endif /* private variables from glut_event.c */ extern GLUTwindow *__glutWindowWorkList; extern int __glutWindowDamaged; #ifdef SUPPORT_FORTRAN extern GLUTtimer *__glutTimerList; extern GLUTtimer *__glutNewTimer; #endif extern GLUTmenu *__glutMappedMenu; extern void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *); #if !defined(_WIN32) extern void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item, int num, int type); extern void (*__glutFinishMenu)(Window win, int x, int y); extern void (*__glutPaintMenu)(GLUTmenu * menu); extern void (*__glutStartMenu)(GLUTmenu * menu, GLUTwindow * window, int x, int y, int x_win, int y_win); extern GLUTmenu * (*__glutGetMenuByNum)(int menunum); extern GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu, Window win, int *which); extern GLUTmenu * (*__glutGetMenu)(Window win); #endif /* private variables from glut_init.c */ extern Atom __glutWMDeleteWindow; extern Display *__glutDisplay; extern unsigned int __glutDisplayMode; extern char *__glutDisplayString; extern XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle, Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc); extern GLboolean __glutDebug; extern GLboolean __glutForceDirect; extern GLboolean __glutIconic; extern GLboolean __glutTryDirect; extern Window __glutRoot; extern XSizeHints __glutSizeHints; extern char **__glutArgv; #endif /* BeOS */ extern char *__glutProgramName; #ifndef __BEOS__ extern int __glutArgc; extern int __glutConnectionFD; extern int __glutInitHeight; extern int __glutInitWidth; extern int __glutInitX; extern int __glutInitY; extern int __glutScreen; extern int __glutScreenHeight; extern int __glutScreenWidth; extern Atom __glutMotifHints; extern unsigned int __glutModifierMask; /* private variables from glut_menu.c */ extern GLUTmenuItem *__glutItemSelected; extern GLUTmenu **__glutMenuList; extern void (*__glutMenuStatusFunc) (int, int, int); extern void __glutMenuModificationError(void); extern void __glutSetMenuItem(GLUTmenuItem * item, const char *label, int value, Bool isTrigger); /* private variables from glut_win.c */ extern GLUTwindow **__glutWindowList; extern GLUTwindow *__glutCurrentWindow; extern GLUTwindow *__glutMenuWindow; extern GLUTmenu *__glutCurrentMenu; extern int __glutWindowListSize; extern void (*__glutFreeOverlayFunc) (GLUToverlay *); extern XVisualInfo *__glutDetermineWindowVisual(Bool * treatAsSingle, Bool * visAlloced, void **fbc); /* private variables from glut_mesa.c */ extern int __glutMesaSwapHackSupport; /* private variables from glut_gamemode.c */ extern GLUTwindow *__glutGameModeWindow; /* private routines from glut_cindex.c */ extern GLUTcolormap * __glutAssociateNewColormap(XVisualInfo * vis); extern void __glutFreeColormap(GLUTcolormap *); /* private routines from glut_cmap.c */ extern void __glutSetupColormap( XVisualInfo * vi, GLUTcolormap ** colormap, Colormap * cmap); #if !defined(_WIN32) extern void __glutEstablishColormapsProperty( GLUTwindow * window); extern GLUTwindow *__glutToplevelOf(GLUTwindow * window); #endif /* private routines from glut_cursor.c */ extern void __glutSetCursor(GLUTwindow *window); /* private routines from glut_event.c */ extern void __glutPutOnWorkList(GLUTwindow * window, int work_mask); extern void __glutRegisterEventParser(GLUTeventParser * parser); extern void __glutPostRedisplay(GLUTwindow * window, int layerMask); /* private routines from glut_init.c */ #if !defined(_WIN32) extern void __glutOpenXConnection(char *display); #else extern void __glutOpenWin32Connection(char *display); #endif extern void __glutInitTime(struct timeval *beginning); /* private routines for glut_menu.c (or win32_menu.c) */ #if defined(_WIN32) extern GLUTmenu *__glutGetMenu(Window win); extern GLUTmenu *__glutGetMenuByNum(int menunum); extern GLUTmenuItem *__glutGetMenuItem(GLUTmenu * menu, Window win, int *which); extern void __glutStartMenu(GLUTmenu * menu, GLUTwindow * window, int x, int y, int x_win, int y_win); extern void __glutFinishMenu(Window win, int x, int y); #endif extern void __glutSetMenu(GLUTmenu * menu); #endif /* BeOS */ #ifdef __cplusplus extern "C" { #endif /* private routines from glut_util.c */ extern char * __glutStrdup(const char *string); extern void __glutWarning(char *format,...); extern void __glutFatalError(char *format,...); extern void __glutFatalUsage(char *format,...); #ifdef __cplusplus } #endif #ifndef __BEOS__ /* private routines from glut_win.c */ extern GLUTwindow *__glutGetWindow(Window win); extern void __glutChangeWindowEventMask(long mask, Bool add); extern XVisualInfo *__glutDetermineVisual( unsigned int mode, Bool * fakeSingle, XVisualInfo * (getVisualInfo) (unsigned int)); extern XVisualInfo *__glutGetVisualInfo(unsigned int mode); extern void __glutSetWindow(GLUTwindow * window); extern void __glutReshapeFunc(GLUTreshapeCB reshapeFunc, int callingConvention); extern void __glutDefaultReshape(int, int); extern GLUTwindow *__glutCreateWindow( GLUTwindow * parent, int x, int y, int width, int height, int gamemode); extern void __glutDestroyWindow( GLUTwindow * window, GLUTwindow * initialWindow); #if !defined(_WIN32) /* private routines from glut_glxext.c */ extern int __glutIsSupportedByGLX(char *); #endif /* private routines from glut_input.c */ extern void __glutUpdateInputDeviceMask(GLUTwindow * window); /* private routines from glut_mesa.c */ extern void __glutDetermineMesaSwapHackSupport(void); /* private routines from glut_gameglut.c */ extern void __glutCloseDownGameMode(void); #if defined(_WIN32) /* private routines from win32_*.c */ extern LONG WINAPI __glutWindowProc(HWND win, UINT msg, WPARAM w, LPARAM l); extern HDC XHDC; #endif #else /* BeOS */ /* BeOS specific C++ function prototypes */ #ifdef __cplusplus #include /* private routines from glutInit.cpp */ void __glutInitTime(bigtime_t *beginning); void __glutInit(); /* private routines from glutMenu.cpp */ class GlutMenu; // avoid including glutMenu.h GlutMenu *__glutGetMenuByNum(int menunum); /* private routines from glutWindow.cpp */ int __glutConvertDisplayMode(unsigned long *options); void __glutDefaultReshape(int width, int height); class GlutWindow; // avoid including glutWindow.h in every source file void __glutSetWindow(GlutWindow * window); void __glutDestroyAllWindows(); /* private routines from glutDstr.cpp */ int __glutConvertDisplayModeFromString(unsigned long *options); /* private routines from glutCursor.cpp */ void __glutSetCursor(int cursor); #endif /* __cplusplus */ #endif /* BeOS */ #endif /* __glutint_h__ */