开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
glutint.h
资源名称：glut23-src.zip　[点击查看]
上传用户：xk288cn
上传日期：2007-05-28
资源大小：4876k
文件大小：28k
源码类别：

GIS编程

开发平台：

Visual C++

glutint.h：源码内容
  1. #ifndef __glutint_h__
  2. #define __glutint_h__
  4. /* Copyright (c) Mark J. Kilgard, 1994, 1997, 1998. */
  6. /* This program is freely distributable without licensing fees 
  7.    and is provided without guarantee or warrantee expressed or 
  8.    implied. This program is -not- in the public domain. */
  10. #if defined(__CYGWIN32__)
  11. #include <sys/time.h>
  12. #endif
  14. #define SUPPORT_FORTRAN  /* With GLUT 3.7, everyone supports Fortran. */
  16. #if defined(_WIN32)
  17. #include "glutwin32.h"
  18. #else
  19. #include <X11/Xlib.h>
  20. #include <X11/Xutil.h>
  21. #include <GL/glx.h>
  22. #endif
  24. #define GLUT_BUILDING_LIB  /* Building the GLUT library itself. */
  26. /* GLUT_BUILDING_LIB is used by <GL/glut.h> to 1) not #pragma link
  27.    with the GLUT library, and 2) avoid the Win32 atexit hack. */
  29. #include <GL/glut.h>
  31. #ifndef CDECL
  32. # if defined(_WIN32) && defined(_MSC_VER)
  33. #  define CDECL __cdecl
  34. # else
  35. #  define CDECL
  36. # endif
  37. #endif
  39. /* This must be done after <GL/gl.h> is included.  MESA is defined
  40.    if the <GL/gl.h> is supplied by Brian Paul's Mesa library. */ 
  41. #if defined(MESA) && defined(_WIN32)
  42. /* Mesa implements "wgl" versions of GDI entry points needed for
  43.    using OpenGL.  Map these "wgl" versions to the GDI names via
  44.    macros. */
  45. WINGDIAPI int WINAPI wglChoosePixelFormat(HDC hdc, CONST PIXELFORMATDESCRIPTOR *ppfd);
  46. WINGDIAPI int WINAPI wglDescribePixelFormat(HDC hdc,int iPixelFormat,UINT nBytes, LPPIXELFORMATDESCRIPTOR ppfd);
  47. WINGDIAPI int WINAPI wglGetPixelFormat(HDC hdc);
  48. WINGDIAPI BOOL WINAPI wglSetPixelFormat(HDC hdc, int iPixelFormat, PIXELFORMATDESCRIPTOR *ppfd);
  49. WINGDIAPI BOOL WINAPI wglSwapBuffers(HDC hdc);
  50. #define ChoosePixelFormat wglChoosePixelFormat
  51. #define DescribePixelFormat wglDescribePixelFormat
  52. #define GetPixelFormat wglGetPixelFormat
  53. #define SetPixelFormat wglSetPixelFormat
  54. #define SwapBuffers wglSwapBuffers
  55. #endif
  57. /* Non-Win32 platforms need APIENTRY defined to nothing
  58.    because all the GLUT routines have the APIENTRY prefix
  59.    to make Win32 happy. */
  60. #ifndef APIENTRY
  61. #define APIENTRY
  62. #endif
  64. #ifdef SUPPORT_FORTRAN
  65. #include <GL/glutf90.h>
  66. #endif
  68. #ifdef __vms
  69. #if ( __VMS_VER < 70000000 )
  70. struct timeval {
  71.   __int64 val;
  72. };
  73. extern int sys$gettim(struct timeval *);
  74. #else
  75. #include <time.h>
  76. #endif
  77. #else
  78. #include <sys/types.h>
  79. #if !defined(_WIN32)
  80. #include <sys/time.h>
  81. #else
  82. #include <winsock.h>
  83. #endif
  84. #endif
  85. #if defined(__vms) && ( __VMS_VER < 70000000 )
  87. /* For VMS6.2 or lower :
  88.    One TICK on VMS is 100 nanoseconds; 0.1 microseconds or
  89.    0.0001 milliseconds. This means that there are 0.01
  90.    ticks/ns, 10 ticks/us, 10,000 ticks/ms and 10,000,000
  91.    ticks/second. */
  93. #define TICKS_PER_MILLISECOND 10000
  94. #define TICKS_PER_SECOND      10000000
  96. #define GETTIMEOFDAY(_x) (void) sys$gettim (_x);
  98. #define ADD_TIME(dest, src1, src2) { 
  99.   (dest).val = (src1).val + (src2).val; 
  100. }
  102. #define TIMEDELTA(dest, src1, src2) { 
  103.   (dest).val = (src1).val - (src2).val; 
  104. }
  106. #define IS_AFTER(t1, t2) ((t2).val > (t1).val)
  108. #define IS_AT_OR_AFTER(t1, t2) ((t2).val >= (t1).val)
  110. #else
  111. #if defined(SVR4) && !defined(sun)  /* Sun claims SVR4, but
  112.                                        wants 2 args. */
  113. #define GETTIMEOFDAY(_x) gettimeofday(_x)
  114. #else
  115. #define GETTIMEOFDAY(_x) gettimeofday(_x, NULL)
  116. #endif
  117. #define ADD_TIME(dest, src1, src2) { 
  118.   if(((dest).tv_usec = 
  119.     (src1).tv_usec + (src2).tv_usec) >= 1000000) { 
  120.     (dest).tv_usec -= 1000000; 
  121.     (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1; 
  122.   } else { 
  123.     (dest).tv_sec = (src1).tv_sec + (src2).tv_sec; 
  124.     if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { 
  125.       (dest).tv_sec --;(dest).tv_usec += 1000000; 
  126.     } 
  127.   } 
  128. }
  129. #define TIMEDELTA(dest, src1, src2) { 
  130.   if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) { 
  131.     (dest).tv_usec += 1000000; 
  132.     (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1; 
  133.   } else { 
  134.      (dest).tv_sec = (src1).tv_sec - (src2).tv_sec; 
  135.   } 
  136. }
  137. #define IS_AFTER(t1, t2) 
  138.   (((t2).tv_sec > (t1).tv_sec) || 
  139.   (((t2).tv_sec == (t1).tv_sec) && 
  140.   ((t2).tv_usec > (t1).tv_usec)))
  141. #define IS_AT_OR_AFTER(t1, t2) 
  142.   (((t2).tv_sec > (t1).tv_sec) || 
  143.   (((t2).tv_sec == (t1).tv_sec) && 
  144.   ((t2).tv_usec >= (t1).tv_usec)))
  145. #endif
  147. #define IGNORE_IN_GAME_MODE() 
  148.   { if (__glutGameModeWindow) return; }
  150. #define GLUT_WIND_IS_RGB(x)         (((x) & GLUT_INDEX) == 0)
  151. #define GLUT_WIND_IS_INDEX(x)       (((x) & GLUT_INDEX) != 0)
  152. #define GLUT_WIND_IS_SINGLE(x)      (((x) & GLUT_DOUBLE) == 0)
  153. #define GLUT_WIND_IS_DOUBLE(x)      (((x) & GLUT_DOUBLE) != 0)
  154. #define GLUT_WIND_HAS_ACCUM(x)      (((x) & GLUT_ACCUM) != 0)
  155. #define GLUT_WIND_HAS_ALPHA(x)      (((x) & GLUT_ALPHA) != 0)
  156. #define GLUT_WIND_HAS_DEPTH(x)      (((x) & GLUT_DEPTH) != 0)
  157. #define GLUT_WIND_HAS_STENCIL(x)    (((x) & GLUT_STENCIL) != 0)
  158. #define GLUT_WIND_IS_MULTISAMPLE(x) (((x) & GLUT_MULTISAMPLE) != 0)
  159. #define GLUT_WIND_IS_STEREO(x)      (((x) & GLUT_STEREO) != 0)
  160. #define GLUT_WIND_IS_LUMINANCE(x)   (((x) & GLUT_LUMINANCE) != 0)
  161. #define GLUT_MAP_WORK               (1 << 0)
  162. #define GLUT_EVENT_MASK_WORK        (1 << 1)
  163. #define GLUT_REDISPLAY_WORK         (1 << 2)
  164. #define GLUT_CONFIGURE_WORK         (1 << 3)
  165. #define GLUT_COLORMAP_WORK          (1 << 4)
  166. #define GLUT_DEVICE_MASK_WORK     (1 << 5)
  167. #define GLUT_FINISH_WORK     (1 << 6)
  168. #define GLUT_DEBUG_WORK     (1 << 7)
  169. #define GLUT_DUMMY_WORK     (1 << 8)
  170. #define GLUT_FULL_SCREEN_WORK       (1 << 9)
  171. #define GLUT_OVERLAY_REDISPLAY_WORK (1 << 10)
  172. #define GLUT_REPAIR_WORK            (1 << 11)
  173. #define GLUT_OVERLAY_REPAIR_WORK    (1 << 12)
  175. /* Frame buffer capability macros and types. */
  176. #define RGBA                    0
  177. #define BUFFER_SIZE             1
  178. #define DOUBLEBUFFER            2
  179. #define STEREO                  3
  180. #define AUX_BUFFERS             4
  181. #define RED_SIZE                5  /* Used as mask bit for
  182.                                       "color selected". */
  183. #define GREEN_SIZE              6
  184. #define BLUE_SIZE               7
  185. #define ALPHA_SIZE              8
  186. #define DEPTH_SIZE              9
  187. #define STENCIL_SIZE            10
  188. #define ACCUM_RED_SIZE          11  /* Used as mask bit for
  189.                                        "acc selected". */
  190. #define ACCUM_GREEN_SIZE        12
  191. #define ACCUM_BLUE_SIZE         13
  192. #define ACCUM_ALPHA_SIZE        14
  193. #define LEVEL                   15
  195. #define NUM_GLXCAPS             (LEVEL + 1)
  197. #define XVISUAL                 (NUM_GLXCAPS + 0)
  198. #define TRANSPARENT             (NUM_GLXCAPS + 1)
  199. #define SAMPLES                 (NUM_GLXCAPS + 2)
  200. #define XSTATICGRAY             (NUM_GLXCAPS + 3)  /* Used as
  201.                                                       mask bit
  202.                                                       for "any
  203.                                                       visual type 
  204.                                                       selected". */
  205. #define XGRAYSCALE              (NUM_GLXCAPS + 4)
  206. #define XSTATICCOLOR            (NUM_GLXCAPS + 5)
  207. #define XPSEUDOCOLOR            (NUM_GLXCAPS + 6)
  208. #define XTRUECOLOR              (NUM_GLXCAPS + 7)
  209. #define XDIRECTCOLOR            (NUM_GLXCAPS + 8)
  210. #define SLOW                    (NUM_GLXCAPS + 9)
  211. #define CONFORMANT              (NUM_GLXCAPS + 10)
  213. #define NUM_CAPS                (NUM_GLXCAPS + 11)
  215. /* Frame buffer capablities that don't have a corresponding
  216.    FrameBufferMode entry.  These get used as mask bits. */
  217. #define NUM                     (NUM_CAPS + 0)
  218. #define RGBA_MODE               (NUM_CAPS + 1)
  219. #define CI_MODE                 (NUM_CAPS + 2)
  220. #define LUMINANCE_MODE (NUM_CAPS + 3)
  222. #define NONE 0
  223. #define EQ 1
  224. #define NEQ 2
  225. #define LTE 3
  226. #define GTE 4
  227. #define GT 5
  228. #define LT 6
  229. #define MIN 7
  231. typedef struct _Criterion {
  232.   int capability;
  233.   int comparison;
  234.   int value;
  235. } Criterion;
  237. typedef struct _FrameBufferMode {
  238.   XVisualInfo *vi;
  239. #if defined(GLX_VERSION_1_1) && defined(GLX_SGIX_fbconfig)
  241.   /* fbc is non-NULL when the XVisualInfo* is not OpenGL-capable
  242.      (ie, GLX_USE_GL is false), but the SGIX_fbconfig extension shows
  243.      the visual's fbconfig is OpenGL-capable.  The reason for this is typically
  244.      an RGBA luminance fbconfig such as 16-bit StaticGray that could
  245.      not be advertised as a GLX visual since StaticGray visuals are
  246.      required (by the GLX specification) to be color index.  The
  247.      SGIX_fbconfig allows StaticGray visuals to instead advertised as
  248.      fbconfigs that can provide RGBA luminance support. */
  250.   GLXFBConfigSGIX fbc;
  251. #endif
  252.   int valid;
  253.   int cap[NUM_CAPS];
  254. } FrameBufferMode;
  256. /* DisplayMode capability macros for game mode. */
  257. #define DM_WIDTH        0  /* "width" */
  258. #define DM_HEIGHT       1  /* "height" */
  259. #define DM_PIXEL_DEPTH  2  /* "bpp" (bits per pixel) */
  260. #define DM_HERTZ        3  /* "hertz" */
  261. #define DM_NUM          4  /* "num" */
  263. #define NUM_DM_CAPS     (DM_NUM+1)
  265. typedef struct _DisplayMode {
  266. #ifdef _WIN32
  267.   DEVMODE devmode;
  268. #else
  269.   /* XXX The X Window System does not have a standard
  270.      mechanism for display setting changes.  On SGI
  271.      systems, GLUT could use the XSGIvc (SGI X video
  272.      control extension).  Perhaps this can be done in
  273.      a future release of GLUT. */
  274. #endif
  275.   int valid;
  276.   int cap[NUM_DM_CAPS];
  277. } DisplayMode;
  279. /* GLUT  function types */
  280. typedef void (GLUTCALLBACK *GLUTdisplayCB) (void);
  281. typedef void (GLUTCALLBACK *GLUTreshapeCB) (int, int);
  282. typedef void (GLUTCALLBACK *GLUTkeyboardCB) (unsigned char, int, int);
  283. typedef void (GLUTCALLBACK *GLUTmouseCB) (int, int, int, int);
  284. typedef void (GLUTCALLBACK *GLUTmotionCB) (int, int);
  285. typedef void (GLUTCALLBACK *GLUTpassiveCB) (int, int);
  286. typedef void (GLUTCALLBACK *GLUTentryCB) (int);
  287. typedef void (GLUTCALLBACK *GLUTvisibilityCB) (int);
  288. typedef void (GLUTCALLBACK *GLUTwindowStatusCB) (int);
  289. typedef void (GLUTCALLBACK *GLUTidleCB) (void);
  290. typedef void (GLUTCALLBACK *GLUTtimerCB) (int);
  291. typedef void (GLUTCALLBACK *GLUTmenuStateCB) (int);  /* DEPRICATED. */
  292. typedef void (GLUTCALLBACK *GLUTmenuStatusCB) (int, int, int);
  293. typedef void (GLUTCALLBACK *GLUTselectCB) (int);
  294. typedef void (GLUTCALLBACK *GLUTspecialCB) (int, int, int);
  295. typedef void (GLUTCALLBACK *GLUTspaceMotionCB) (int, int, int);
  296. typedef void (GLUTCALLBACK *GLUTspaceRotateCB) (int, int, int);
  297. typedef void (GLUTCALLBACK *GLUTspaceButtonCB) (int, int);
  298. typedef void (GLUTCALLBACK *GLUTdialsCB) (int, int);
  299. typedef void (GLUTCALLBACK *GLUTbuttonBoxCB) (int, int);
  300. typedef void (GLUTCALLBACK *GLUTtabletMotionCB) (int, int);
  301. typedef void (GLUTCALLBACK *GLUTtabletButtonCB) (int, int, int, int);
  302. typedef void (GLUTCALLBACK *GLUTjoystickCB) (unsigned int buttonMask, int x, int y, int z);
  304. typedef struct _GLUTcolorcell GLUTcolorcell;
  305. struct _GLUTcolorcell {
  306.   /* GLUT_RED, GLUT_GREEN, GLUT_BLUE */
  307.   GLfloat component[3];
  308. };
  310. typedef struct _GLUTcolormap GLUTcolormap;
  311. struct _GLUTcolormap {
  312.   Visual *visual;       /* visual of the colormap */
  313.   Colormap cmap;        /* X colormap ID */
  314.   int refcnt;           /* number of windows using colormap */
  315.   int size;             /* number of cells in colormap */
  316.   int transparent;      /* transparent pixel, or -1 if opaque */
  317.   GLUTcolorcell *cells; /* array of cells */
  318.   GLUTcolormap *next;   /* next colormap in list */
  319. };
  321. typedef struct _GLUTwindow GLUTwindow;
  322. typedef struct _GLUToverlay GLUToverlay;
  323. struct _GLUTwindow {
  324.   int num;              /* Small integer window id (0-based). */
  326.   /* Window system related state. */
  327. #if defined(_WIN32)
  328.   int pf;               /* Pixel format. */
  329.   HDC hdc;              /* Window's Win32 device context. */
  330. #endif
  331.   Window win;           /* X window for GLUT window */
  332.   GLXContext ctx;       /* OpenGL context GLUT glut window */
  333.   XVisualInfo *vis;     /* visual for window */
  334.   Bool visAlloced;      /* if vis needs deallocate on destroy */
  335.   Colormap cmap;        /* RGB colormap for window; None if CI */
  336.   GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
  337.   GLUToverlay *overlay; /* overlay; NULL if no overlay */
  338. #if defined(_WIN32)
  339.   HDC renderDc;         /* Win32's device context for rendering. */
  340. #endif
  341.   Window renderWin;     /* X window for rendering (might be
  342.                            overlay) */
  343.   GLXContext renderCtx; /* OpenGL context for rendering (might
  344.                            be overlay) */
  345.   /* GLUT settable or visible window state. */
  346.   int width;            /* window width in pixels */
  347.   int height;           /* window height in pixels */
  348.   int cursor;           /* cursor name */
  349.   int visState;         /* visibility state (-1 is unknown) */
  350.   int shownState;       /* if window mapped */
  351.   int entryState;       /* entry state (-1 is unknown) */
  352. #define GLUT_MAX_MENUS              3
  354.   int menu[GLUT_MAX_MENUS];  /* attatched menu nums */
  355.   /* Window relationship state. */
  356.   GLUTwindow *parent;   /* parent window */
  357.   GLUTwindow *children; /* list of children */
  358.   GLUTwindow *siblings; /* list of siblings */
  359.   /* Misc. non-API visible (hidden) state. */
  360.   Bool treatAsSingle;   /* treat this window as single-buffered
  361.                            (it might be "fake" though) */
  362.   Bool forceReshape;    /* force reshape before display */
  363. #if !defined(_WIN32)
  364.   Bool isDirect;        /* if direct context (X11 only) */
  365. #endif
  366.   Bool usedSwapBuffers; /* if swap buffers used last display */
  367.   long eventMask;       /* mask of X events selected for */
  368.   int buttonUses;       /* number of button uses, ref cnt */
  369.   int tabletPos[2];     /* tablet position (-1 is invalid) */
  370.   /* Work list related state. */
  371.   unsigned int workMask;  /* mask of window work to be done */
  372.   GLUTwindow *prevWorkWin;  /* link list of windows to work on */
  373.   Bool desiredMapState; /* how to mapped window if on map work
  374.                            list */
  375.   Bool ignoreKeyRepeat;  /* if window ignores autorepeat */
  376.   int desiredConfMask;  /* mask of desired window configuration
  377.                          */
  378.   int desiredX;         /* desired X location */
  379.   int desiredY;         /* desired Y location */
  380.   int desiredWidth;     /* desired window width */
  381.   int desiredHeight;    /* desired window height */
  382.   int desiredStack;     /* desired window stack */
  383.   /* Per-window callbacks. */
  384.   GLUTdisplayCB display;  /* redraw */
  385.   GLUTreshapeCB reshape;  /* resize (width,height) */
  386.   GLUTmouseCB mouse;    /* mouse (button,state,x,y) */
  387.   GLUTmotionCB motion;  /* motion (x,y) */
  388.   GLUTpassiveCB passive;  /* passive motion (x,y) */
  389.   GLUTentryCB entry;    /* window entry/exit (state) */
  390.   GLUTkeyboardCB keyboard;  /* keyboard (ASCII,x,y) */
  391.   GLUTkeyboardCB keyboardUp;  /* keyboard up (ASCII,x,y) */
  392.   GLUTwindowStatusCB windowStatus;  /* window status */
  393.   GLUTvisibilityCB visibility;  /* visibility */
  394.   GLUTspecialCB special;  /* special key */
  395.   GLUTspecialCB specialUp;  /* special up key */
  396.   GLUTbuttonBoxCB buttonBox;  /* button box */
  397.   GLUTdialsCB dials;    /* dials */
  398.   GLUTspaceMotionCB spaceMotion;  /* Spaceball motion */
  399.   GLUTspaceRotateCB spaceRotate;  /* Spaceball rotate */
  400.   GLUTspaceButtonCB spaceButton;  /* Spaceball button */
  401.   GLUTtabletMotionCB tabletMotion;  /* tablet motion */
  402.   GLUTtabletButtonCB tabletButton;  /* tablet button */
  403. #ifdef _WIN32
  404.   GLUTjoystickCB joystick;  /* joystick */
  405.   int joyPollInterval; /* joystick polling interval */
  406. #endif
  407. #ifdef SUPPORT_FORTRAN
  408.   GLUTdisplayFCB fdisplay;  /* Fortran display  */
  409.   GLUTreshapeFCB freshape;  /* Fortran reshape  */
  410.   GLUTmouseFCB fmouse;  /* Fortran mouse  */
  411.   GLUTmotionFCB fmotion;  /* Fortran motion  */
  412.   GLUTpassiveFCB fpassive;  /* Fortran passive  */
  413.   GLUTentryFCB fentry;  /* Fortran entry  */
  414.   GLUTkeyboardFCB fkeyboard;  /* Fortran keyboard  */
  415.   GLUTkeyboardFCB fkeyboardUp;  /* Fortran keyboard up */
  416.   GLUTwindowStatusFCB fwindowStatus;  /* Fortran window status */
  417.   GLUTvisibilityFCB fvisibility;  /* Fortran visibility */
  418.   GLUTspecialFCB fspecial;  /* special key */
  419.   GLUTspecialFCB fspecialUp;  /* special key up */
  420.   GLUTbuttonBoxFCB fbuttonBox;  /* button box */
  421.   GLUTdialsFCB fdials;  /* dials */
  422.   GLUTspaceMotionFCB fspaceMotion;  /* Spaceball motion */
  423.   GLUTspaceRotateFCB fspaceRotate;  /* Spaceball rotate */
  424.   GLUTspaceButtonFCB fspaceButton;  /* Spaceball button */
  425.   GLUTtabletMotionFCB ftabletMotion;  /* tablet motion */
  426.   GLUTtabletButtonFCB ftabletButton;  /* tablet button */
  427. #ifdef _WIN32
  428.   GLUTjoystickFCB fjoystick;  /* joystick */
  429. #endif
  430. #endif
  431. };
  433. struct _GLUToverlay {
  434. #if defined(_WIN32)
  435.   int pf;
  436.   HDC hdc;
  437. #endif
  438.   Window win;
  439.   GLXContext ctx;
  440.   XVisualInfo *vis;     /* visual for window */
  441.   Bool visAlloced;      /* if vis needs deallocate on destroy */
  442.   Colormap cmap;        /* RGB colormap for window; None if CI */
  443.   GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
  444.   int shownState;       /* if overlay window mapped */
  445.   Bool treatAsSingle;   /* treat as single-buffered */
  446. #if !defined(_WIN32)
  447.   Bool isDirect;        /* if direct context */
  448. #endif
  449.   int transparentPixel; /* transparent pixel value */
  450.   GLUTdisplayCB display;  /* redraw  */
  451. #ifdef SUPPORT_FORTRAN
  452.   GLUTdisplayFCB fdisplay;  /* redraw  */
  453. #endif
  454. };
  456. typedef struct _GLUTstale GLUTstale;
  457. struct _GLUTstale {
  458.   GLUTwindow *window;
  459.   Window win;
  460.   GLUTstale *next;
  461. };
  463. extern GLUTstale *__glutStaleWindowList;
  465. #define GLUT_OVERLAY_EVENT_FILTER_MASK 
  466.   (ExposureMask | 
  467.   StructureNotifyMask | 
  468.   EnterWindowMask | 
  469.   LeaveWindowMask)
  470. #define GLUT_DONT_PROPAGATE_FILTER_MASK 
  471.   (ButtonReleaseMask | 
  472.   ButtonPressMask | 
  473.   KeyPressMask | 
  474.   KeyReleaseMask | 
  475.   PointerMotionMask | 
  476.   Button1MotionMask | 
  477.   Button2MotionMask | 
  478.   Button3MotionMask)
  479. #define GLUT_HACK_STOP_PROPAGATE_MASK 
  480.   (KeyPressMask | 
  481.   KeyReleaseMask)
  483. typedef struct _GLUTmenu GLUTmenu;
  484. typedef struct _GLUTmenuItem GLUTmenuItem;
  485. struct _GLUTmenu {
  486.   int id;               /* small integer menu id (0-based) */
  487. #if defined(_WIN32)
  488.   HMENU win;            /* Win32 menu */
  489. #else
  490.   Window win;           /* X window for the menu */
  491. #endif
  492.   GLUTselectCB select;  /*  function of menu */
  493.   GLUTmenuItem *list;   /* list of menu entries */
  494.   int num;              /* number of entries */
  495. #if !defined(_WIN32)
  496.   Bool managed;         /* are the InputOnly windows size
  497.                            validated? */
  498.   Bool searched; /* help detect menu loops */
  499.   int pixheight;        /* height of menu in pixels */
  500.   int pixwidth;         /* width of menu in pixels */
  501. #endif
  502.   int submenus;         /* number of submenu entries */
  503.   GLUTmenuItem *highlighted;  /* pointer to highlighted menu
  504.                                  entry, NULL not highlighted */
  505.   GLUTmenu *cascade;    /* currently cascading this menu  */
  506.   GLUTmenuItem *anchor; /* currently anchored to this entry */
  507.   int x;                /* current x origin relative to the
  508.                            root window */
  509.   int y;                /* current y origin relative to the
  510.                            root window */
  511. #ifdef SUPPORT_FORTRAN
  512.   GLUTselectFCB fselect;  /*  function of menu */
  513. #endif
  514. };
  516. struct _GLUTmenuItem {
  517. #if defined(_WIN32)
  518.   HMENU win;            /* Win32 window for entry */
  519. #else
  520.   Window win;           /* InputOnly X window for entry */
  521. #endif
  522.   GLUTmenu *menu;       /* menu entry belongs to */
  523.   Bool isTrigger;       /* is a submenu trigger? */
  524.   int value;            /* value to return for selecting this
  525.                            entry; doubles as submenu id
  526.                            (0-base) if submenu trigger */
  527. #if defined(_WIN32)
  528.   UINT unique;          /* unique menu item id (Win32 only) */
  529. #endif
  530.   char *label;          /* __glutStrdup'ed label string */
  531.   int len;              /* length of label string */
  532.   int pixwidth;         /* width of X window in pixels */
  533.   GLUTmenuItem *next;   /* next menu entry on list for menu */
  534. };
  536. typedef struct _GLUTtimer GLUTtimer;
  537. struct _GLUTtimer {
  538.   GLUTtimer *next;      /* list of timers */
  539.   struct timeval timeout;  /* time to be called */
  540.   GLUTtimerCB func;     /* timer  (value) */
  541.   int value;            /*  return value */
  542. #ifdef SUPPORT_FORTRAN
  543.   GLUTtimerFCB ffunc;   /* Fortran timer  */
  544. #endif
  545. };
  547. typedef struct _GLUTeventParser GLUTeventParser;
  548. struct _GLUTeventParser {
  549.   int (*func) (XEvent *);
  550.   GLUTeventParser *next;
  551. };
  553. /* Declarations to implement glutFullScreen support with
  554.    mwm/4Dwm. */
  556. /* The following X property format is defined in Motif 1.1's
  557.    Xm/MwmUtils.h, but GLUT should not depend on that header
  558.    file. Note: Motif 1.2 expanded this structure with
  559.    uninteresting fields (to GLUT) so just stick with the
  560.    smaller Motif 1.1 structure. */
  561. typedef struct {
  562. #define MWM_HINTS_DECORATIONS   2
  563.   long flags;
  564.   long functions;
  565.   long decorations;
  566.   long input_mode;
  567. } MotifWmHints;
  569. /* Make current and buffer swap macros. */
  570. #ifdef _WIN32
  571. #define MAKE_CURRENT_LAYER(window)                                    
  572.   {                                                                   
  573.     HGLRC currentContext = wglGetCurrentContext();                    
  574.     HDC currentDc = wglGetCurrentDC();                                
  575.                                                                       
  576.     if (currentContext != window->renderCtx                           
  577.       || currentDc != window->renderDc) {                             
  578.       wglMakeCurrent(window->renderDc, window->renderCtx);            
  579.     }                                                                 
  580.   }
  581. #define MAKE_CURRENT_WINDOW(window)                                   
  582.   {                                                                   
  583.     HGLRC currentContext = wglGetCurrentContext();                    
  584.     HDC currentDc = wglGetCurrentDC();                                
  585.                                                                       
  586.     if (currentContext != window->ctx || currentDc != window->hdc) {  
  587.       wglMakeCurrent(window->hdc, window->ctx);                       
  588.     }                                                                 
  589.   }
  590. #define MAKE_CURRENT_OVERLAY(overlay) 
  591.   wglMakeCurrent(overlay->hdc, overlay->ctx)
  592. #define UNMAKE_CURRENT() 
  593.   wglMakeCurrent(NULL, NULL)
  594. #define SWAP_BUFFERS_WINDOW(window) 
  595.   SwapBuffers(window->hdc)
  596. #define SWAP_BUFFERS_LAYER(window) 
  597.   SwapBuffers(window->renderDc)
  598. #else
  599. #define MAKE_CURRENT_LAYER(window) 
  600.   glXMakeCurrent(__glutDisplay, window->renderWin, window->renderCtx)
  601. #define MAKE_CURRENT_WINDOW(window) 
  602.   glXMakeCurrent(__glutDisplay, window->win, window->ctx)
  603. #define MAKE_CURRENT_OVERLAY(overlay) 
  604.   glXMakeCurrent(__glutDisplay, overlay->win, overlay->ctx)
  605. #define UNMAKE_CURRENT() 
  606.   glXMakeCurrent(__glutDisplay, None, NULL)
  607. #define SWAP_BUFFERS_WINDOW(window) 
  608.   glXSwapBuffers(__glutDisplay, window->win)
  609. #define SWAP_BUFFERS_LAYER(window) 
  610.   glXSwapBuffers(__glutDisplay, window->renderWin)
  611. #endif
  613. /* private variables from glut_event.c */
  614. extern GLUTwindow *__glutWindowWorkList;
  615. extern int __glutWindowDamaged;
  616. #ifdef SUPPORT_FORTRAN
  617. extern GLUTtimer *__glutTimerList;
  618. extern GLUTtimer *__glutNewTimer;
  619. #endif
  620. extern GLUTmenu *__glutMappedMenu;
  622. extern void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);
  623. #if !defined(_WIN32)
  624. extern void (*__glutMenuItemEnterOrLeave)(GLUTmenuItem * item,
  625.   int num, int type);
  626. extern void (*__glutFinishMenu)(Window win, int x, int y);
  627. extern void (*__glutPaintMenu)(GLUTmenu * menu);
  628. extern void (*__glutStartMenu)(GLUTmenu * menu,
  629.   GLUTwindow * window, int x, int y, int x_win, int y_win);
  630. extern GLUTmenu * (*__glutGetMenuByNum)(int menunum);
  631. extern GLUTmenuItem * (*__glutGetMenuItem)(GLUTmenu * menu,
  632.   Window win, int *which);
  633. extern GLUTmenu * (*__glutGetMenu)(Window win);
  634. #endif
  636. /* private variables from glut_init.c */
  637. extern Atom __glutWMDeleteWindow;
  638. extern Display *__glutDisplay;
  639. extern unsigned int __glutDisplayMode;
  640. extern char *__glutDisplayString;
  641. extern XVisualInfo *(*__glutDetermineVisualFromString) (char *string, Bool * treatAsSingle,
  642.   Criterion * requiredCriteria, int nRequired, int requiredMask, void **fbc);
  643. extern GLboolean __glutDebug;
  644. extern GLboolean __glutForceDirect;
  645. extern GLboolean __glutIconic;
  646. extern GLboolean __glutTryDirect;
  647. extern Window __glutRoot;
  648. extern XSizeHints __glutSizeHints;
  649. extern char **__glutArgv;
  650. extern char *__glutProgramName;
  651. extern int __glutArgc;
  652. extern int __glutConnectionFD;
  653. extern int __glutInitHeight;
  654. extern int __glutInitWidth;
  655. extern int __glutInitX;
  656. extern int __glutInitY;
  657. extern int __glutScreen;
  658. extern int __glutScreenHeight;
  659. extern int __glutScreenWidth;
  660. extern Atom __glutMotifHints;
  661. extern unsigned int __glutModifierMask;
  662. #ifdef _WIN32
  663. extern void (__cdecl *__glutExitFunc)(int retval);
  664. #endif
  666. /* private variables from glut_menu.c */
  667. extern GLUTmenuItem *__glutItemSelected;
  668. extern GLUTmenu **__glutMenuList;
  669. extern void (GLUTCALLBACK *__glutMenuStatusFunc) (int, int, int);
  670. extern void __glutMenuModificationError(void);
  671. extern void __glutSetMenuItem(GLUTmenuItem * item,
  672.   const char *label, int value, Bool isTrigger);
  674. /* private variables from glut_win.c */
  675. extern GLUTwindow **__glutWindowList;
  676. extern GLUTwindow *__glutCurrentWindow;
  677. extern GLUTwindow *__glutMenuWindow;
  678. extern GLUTmenu *__glutCurrentMenu;
  679. extern int __glutWindowListSize;
  680. extern void (*__glutFreeOverlayFunc) (GLUToverlay *);
  681. extern XVisualInfo *__glutDetermineWindowVisual(Bool * treatAsSingle,
  682.   Bool * visAlloced, void **fbc);
  684. /* private variables from glut_mesa.c */
  685. extern int __glutMesaSwapHackSupport;
  687. /* private variables from glut_gamemode.c */
  688. extern GLUTwindow *__glutGameModeWindow;
  690. /* private routines from glut_cindex.c */
  691. extern GLUTcolormap * __glutAssociateNewColormap(XVisualInfo * vis);
  692. extern void __glutFreeColormap(GLUTcolormap *);
  694. /* private routines from glut_cmap.c */
  695. extern void __glutSetupColormap(
  696.   XVisualInfo * vi,
  697.   GLUTcolormap ** colormap,
  698.   Colormap * cmap);
  699. #if !defined(_WIN32)
  700. extern void __glutEstablishColormapsProperty(
  701.   GLUTwindow * window);
  702. extern GLUTwindow *__glutToplevelOf(GLUTwindow * window);
  703. #endif
  705. /* private routines from glut_cursor.c */
  706. extern void __glutSetCursor(GLUTwindow *window);
  708. /* private routines from glut_event.c */
  709. extern void __glutPutOnWorkList(GLUTwindow * window,
  710.   int work_mask);
  711. extern void __glutRegisterEventParser(GLUTeventParser * parser);
  712. extern void __glutPostRedisplay(GLUTwindow * window, int layerMask);
  714. /* private routines from glut_init.c */
  715. #if !defined(_WIN32)
  716. extern void __glutOpenXConnection(char *display);
  717. #else
  718. extern void __glutOpenWin32Connection(char *display);
  719. #endif
  720. extern void __glutInitTime(struct timeval *beginning);
  722. /* private routines for glut_menu.c (or win32_menu.c) */
  723. #if defined(_WIN32)
  724. extern GLUTmenu *__glutGetMenu(HMENU win);
  725. extern GLUTmenu *__glutGetMenuByNum(int menunum);
  726. extern GLUTmenuItem *__glutGetMenuItem(GLUTmenu * menu,
  727.   HMENU win, int *which);
  728. extern void __glutStartMenu(GLUTmenu * menu,
  729.   GLUTwindow * window, int x, int y, int x_win, int y_win);
  730. extern void __glutFinishMenu(Window win, int x, int y);
  731. #endif
  732. extern void __glutSetMenu(GLUTmenu * menu);
  734. /* private routines from glut_util.c */
  735. extern char * __glutStrdup(const char *string);
  736. extern void __glutWarning(char *format,...);
  737. extern void __glutFatalError(char *format,...);
  738. extern void __glutFatalUsage(char *format,...);
  740. /* private routines from glut_win.c */
  741. extern GLUTwindow *__glutGetWindow(Window win);
  742. extern void __glutChangeWindowEventMask(long mask, Bool add);
  743. extern XVisualInfo *__glutDetermineVisual(
  744.   unsigned int mode,
  745.   Bool * fakeSingle,
  746.   XVisualInfo * (getVisualInfo) (unsigned int));
  747. extern XVisualInfo *__glutGetVisualInfo(unsigned int mode);
  748. extern void __glutSetWindow(GLUTwindow * window);
  749. extern void __glutReshapeFunc(GLUTreshapeCB reshapeFunc,
  750.   int callingConvention);
  751. extern void GLUTCALLBACK __glutDefaultReshape(int, int);
  752. extern GLUTwindow *__glutCreateWindow(
  753.   GLUTwindow * parent,
  754.   int x, int y, int width, int height, int gamemode);
  755. extern void __glutDestroyWindow(
  756.   GLUTwindow * window,
  757.   GLUTwindow * initialWindow);
  759. #if !defined(_WIN32)
  760. /* private routines from glut_glxext.c */
  761. extern int __glutIsSupportedByGLX(char *);
  762. #endif
  764. /* private routines from glut_input.c */
  765. extern void  __glutUpdateInputDeviceMask(GLUTwindow * window);
  767. /* private routines from glut_mesa.c */
  768. extern void __glutDetermineMesaSwapHackSupport(void);
  770. /* private routines from glut_gameglut.c */
  771. extern void CDECL __glutCloseDownGameMode(void);
  773. #if defined(_WIN32)
  774. /* private routines from win32_*.c */
  775. extern LONG WINAPI __glutWindowProc(HWND win, UINT msg, WPARAM w, LPARAM l);
  776. extern HDC XHDC;
  777. #endif
  779. #endif /* __glutint_h__ */