freeglut_spaceball.c
上传用户:gb3593
上传日期:2022-01-07
资源大小:3028k
文件大小:11k
源码类别:

游戏引擎

开发平台:

Visual C++

  1. /* Spaceball support for Linux.
  2.  * Written by John Tsiombikas <nuclear@member.fsf.org>
  3.  *
  4.  * This code supports 3Dconnexion's 6-dof space-whatever devices.
  5.  * It can communicate with either the proprietary 3Dconnexion daemon (3dxsrv)
  6.  * free spacenavd (http://spacenav.sourceforge.net), through the "standard"
  7.  * magellan X-based protocol.
  8.  */
  9. #include <GL/freeglut.h>
  10. #include "freeglut_internal.h"
  11. #if TARGET_HOST_POSIX_X11
  12. #include <X11/Xlib.h>
  13. enum {
  14.     SPNAV_EVENT_ANY,  /* used by spnav_remove_events() */
  15.     SPNAV_EVENT_MOTION,
  16.     SPNAV_EVENT_BUTTON  /* includes both press and release */
  17. };
  18. struct spnav_event_motion {
  19.     int type;
  20.     int x, y, z;
  21.     int rx, ry, rz;
  22.     unsigned int period;
  23.     int *data;
  24. };
  25. struct spnav_event_button {
  26.     int type;
  27.     int press;
  28.     int bnum;
  29. };
  30. typedef union spnav_event {
  31.     int type;
  32.     struct spnav_event_motion motion;
  33.     struct spnav_event_button button;
  34. } spnav_event;
  35. static int spnav_x11_open(Display *dpy, Window win);
  36. static int spnav_x11_window(Window win);
  37. static int spnav_x11_event(const XEvent *xev, spnav_event *event);
  38. static int spnav_close(void);
  39. static int spnav_fd(void);
  40. static int spnav_remove_events(int type);
  41. static SFG_Window *spnav_win;
  42. #endif
  43. static int sball_initialized;
  44. void fgInitialiseSpaceball(void)
  45. {
  46.     if(sball_initialized) {
  47.         return;
  48.     }
  49. #if TARGET_HOST_POSIX_X11
  50.     {
  51.         Window w;
  52.         if(!fgStructure.CurrentWindow)
  53.             return;
  54.         w = fgStructure.CurrentWindow->Window.Handle;
  55.         if(spnav_x11_open(fgDisplay.Display, w) == -1) {
  56.             return;
  57.         }
  58.     }
  59. #endif
  60.     sball_initialized = 1;
  61. }
  62. void fgSpaceballClose(void)
  63. {
  64. #if TARGET_HOST_POSIX_X11
  65.     spnav_close();
  66. #endif
  67. }
  68. int fgHasSpaceball(void)
  69. {
  70.     if(!sball_initialized) {
  71.         fgInitialiseSpaceball();
  72.         if(!sball_initialized) {
  73.             fgWarning("fgInitialiseSpaceball failedn");
  74.             return 0;
  75.         }
  76.     }
  77. #if TARGET_HOST_POSIX_X11
  78.     /* XXX this function should somehow query the driver if there's a device
  79.      * plugged in, as opposed to just checking if there's a driver to talk to.
  80.      */
  81.     return spnav_fd() == -1 ? 0 : 1;
  82. #else
  83.     return 0;
  84. #endif
  85. }
  86. int fgSpaceballNumButtons(void)
  87. {
  88.     if(!sball_initialized) {
  89.         fgInitialiseSpaceball();
  90.         if(!sball_initialized) {
  91.             fgWarning("fgInitialiseSpaceball failedn");
  92.             return 0;
  93.         }
  94.     }
  95. #if TARGET_HOST_POSIX_X11
  96.     return 2;  /* TODO implement this properly */
  97. #else
  98.     return 0;
  99. #endif
  100. }
  101. void fgSpaceballSetWindow(SFG_Window *window)
  102. {
  103.     if(!sball_initialized) {
  104.         fgInitialiseSpaceball();
  105.         if(!sball_initialized) {
  106.             return;
  107.         }
  108.     }
  109. #if TARGET_HOST_POSIX_X11
  110.     if(spnav_win != window) {
  111.         spnav_x11_window(window->Window.Handle);
  112.         spnav_win = window;
  113.     }
  114. #endif
  115. }
  116. #if TARGET_HOST_POSIX_X11
  117. int fgIsSpaceballXEvent(const XEvent *xev)
  118. {
  119.     spnav_event sev;
  120.     if(!sball_initialized) {
  121.         fgInitialiseSpaceball();
  122.         if(!sball_initialized) {
  123.             return 0;
  124.         }
  125.     }
  126.     return spnav_x11_event(xev, &sev);
  127. }
  128. void fgSpaceballHandleXEvent(const XEvent *xev)
  129. {
  130.     spnav_event sev;
  131.     if(!sball_initialized) {
  132.         fgInitialiseSpaceball();
  133.         if(!sball_initialized) {
  134.             return;
  135.         }
  136.     }
  137.     if(spnav_x11_event(xev, &sev)) {
  138.         switch(sev.type) {
  139.         case SPNAV_EVENT_MOTION:
  140.             if(sev.motion.x | sev.motion.y | sev.motion.z) {
  141.                 INVOKE_WCB(*spnav_win, SpaceMotion, (sev.motion.x, sev.motion.y, sev.motion.z));
  142.             }
  143.             if(sev.motion.rx | sev.motion.ry | sev.motion.rz) {
  144.                 INVOKE_WCB(*spnav_win, SpaceRotation, (sev.motion.rx, sev.motion.ry, sev.motion.rz));
  145.             }
  146.             spnav_remove_events(SPNAV_EVENT_MOTION);
  147.             break;
  148.         case SPNAV_EVENT_BUTTON:
  149.             INVOKE_WCB(*spnav_win, SpaceButton, (sev.button.bnum, sev.button.press ? GLUT_DOWN : GLUT_UP));
  150.             break;
  151.         default:
  152.             break;
  153.         }
  154.     }
  155. }
  156. /*
  157. The following code is part of libspnav, part of the spacenav project (spacenav.sf.net)
  158. Copyright (C) 2007-2009 John Tsiombikas <nuclear@member.fsf.org>
  159. Redistribution and use in source and binary forms, with or without
  160. modification, are permitted provided that the following conditions are met:
  161. 1. Redistributions of source code must retain the above copyright notice, this
  162.    list of conditions and the following disclaimer.
  163. 2. Redistributions in binary form must reproduce the above copyright notice,
  164.    this list of conditions and the following disclaimer in the documentation
  165.    and/or other materials provided with the distribution.
  166. 3. The name of the author may not be used to endorse or promote products
  167.    derived from this software without specific prior written permission.
  168. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  169. WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  170. MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  171. EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  172. EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  173. OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  174. INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  175. CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  176. IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  177. OF SUCH DAMAGE.
  178. */
  179. #include <stdio.h>
  180. #include <stdlib.h>
  181. #include <string.h>
  182. #include <errno.h>
  183. #include <X11/Xlib.h>
  184. #include <X11/Xutil.h>
  185. static Window get_daemon_window(Display *dpy);
  186. static int catch_badwin(Display *dpy, XErrorEvent *err);
  187. static Display *dpy;
  188. static Window app_win;
  189. static Atom motion_event, button_press_event, button_release_event, command_event;
  190. enum {
  191.   CMD_APP_WINDOW = 27695,
  192.   CMD_APP_SENS
  193. };
  194. #define IS_OPEN    dpy
  195. struct event_node {
  196.   spnav_event event;
  197.   struct event_node *next;
  198. };
  199. static int spnav_x11_open(Display *display, Window win)
  200. {
  201.   if(IS_OPEN) {
  202.     return -1;
  203.   }
  204.   dpy = display;
  205.   motion_event = XInternAtom(dpy, "MotionEvent", True);
  206.   button_press_event = XInternAtom(dpy, "ButtonPressEvent", True);
  207.   button_release_event = XInternAtom(dpy, "ButtonReleaseEvent", True);
  208.   command_event = XInternAtom(dpy, "CommandEvent", True);
  209.   if(!motion_event || !button_press_event || !button_release_event || !command_event) {
  210.     dpy = 0;
  211.     return -1;  /* daemon not started */
  212.   }
  213.   if(spnav_x11_window(win) == -1) {
  214.     dpy = 0;
  215.     return -1;  /* daemon not started */
  216.   }
  217.   app_win = win;
  218.   return 0;
  219. }
  220. static int spnav_close(void)
  221. {
  222.   if(dpy) {
  223.     spnav_x11_window(DefaultRootWindow(dpy));
  224.     app_win = 0;
  225.     dpy = 0;
  226.     return 0;
  227.   }
  228.   return -1;
  229. }
  230. static int spnav_x11_window(Window win)
  231. {
  232.   int (*prev_xerr_handler)(Display*, XErrorEvent*);
  233.   XEvent xev;
  234.   Window daemon_win;
  235.   if(!IS_OPEN) {
  236.     return -1;
  237.   }
  238.   if(!(daemon_win = get_daemon_window(dpy))) {
  239.     return -1;
  240.   }
  241.   prev_xerr_handler = XSetErrorHandler(catch_badwin);
  242.   xev.type = ClientMessage;
  243.   xev.xclient.send_event = False;
  244.   xev.xclient.display = dpy;
  245.   xev.xclient.window = win;
  246.   xev.xclient.message_type = command_event;
  247.   xev.xclient.format = 16;
  248.   xev.xclient.data.s[0] = ((unsigned int)win & 0xffff0000) >> 16;
  249.   xev.xclient.data.s[1] = (unsigned int)win & 0xffff;
  250.   xev.xclient.data.s[2] = CMD_APP_WINDOW;
  251.   XSendEvent(dpy, daemon_win, False, 0, &xev);
  252.   XSync(dpy, False);
  253.   XSetErrorHandler(prev_xerr_handler);
  254.   return 0;
  255. }
  256. static int spnav_fd(void)
  257. {
  258.   if(dpy) {
  259.     return ConnectionNumber(dpy);
  260.   }
  261.   return -1;
  262. }
  263. /*static int spnav_wait_event(spnav_event *event)
  264. {
  265.   if(dpy) {
  266.     for(;;) {
  267.       XEvent xev;
  268.       XNextEvent(dpy, &xev);
  269.       if(spnav_x11_event(&xev, event) > 0) {
  270.         return event->type;
  271.       }
  272.     }
  273.   }
  274.   return 0;
  275. }
  276. static int spnav_poll_event(spnav_event *event)
  277. {
  278.   if(dpy) {
  279.     if(XPending(dpy)) {
  280.       XEvent xev;
  281.       XNextEvent(dpy, &xev);
  282.       return spnav_x11_event(&xev, event);
  283.     }
  284.   }
  285.   return 0;
  286. }*/
  287. static Bool match_events(Display *dpy, XEvent *xev, char *arg)
  288. {
  289.   int evtype = *(int*)arg;
  290.   if(xev->type != ClientMessage) {
  291.     return False;
  292.   }
  293.   if(xev->xclient.message_type == motion_event) {
  294.     return !evtype || evtype == SPNAV_EVENT_MOTION ? True : False;
  295.   }
  296.   if(xev->xclient.message_type == button_press_event ||
  297.       xev->xclient.message_type == button_release_event) {
  298.     return !evtype || evtype == SPNAV_EVENT_BUTTON ? True : False;
  299.   }
  300.   return False;
  301. }
  302. static int spnav_remove_events(int type)
  303. {
  304.   int rm_count = 0;
  305.   if(dpy) {
  306.     XEvent xev;
  307.     while(XCheckIfEvent(dpy, &xev, match_events, (char*)&type)) {
  308.       rm_count++;
  309.     }
  310.     return rm_count;
  311.   }
  312.   return 0;
  313. }
  314. static int spnav_x11_event(const XEvent *xev, spnav_event *event)
  315. {
  316.   int i;
  317.   int xmsg_type;
  318.   if(xev->type != ClientMessage) {
  319.     return 0;
  320.   }
  321.   xmsg_type = xev->xclient.message_type;
  322.   if(xmsg_type != motion_event && xmsg_type != button_press_event &&
  323.       xmsg_type != button_release_event) {
  324.     return 0;
  325.   }
  326.   if(xmsg_type == motion_event) {
  327.     event->type = SPNAV_EVENT_MOTION;
  328.     event->motion.data = &event->motion.x;
  329.     for(i=0; i<6; i++) {
  330.       event->motion.data[i] = xev->xclient.data.s[i + 2];
  331.     }
  332.     event->motion.period = xev->xclient.data.s[8];
  333.   } else {
  334.     event->type = SPNAV_EVENT_BUTTON;
  335.     event->button.press = xmsg_type == button_press_event ? 1 : 0;
  336.     event->button.bnum = xev->xclient.data.s[2];
  337.   }
  338.   return event->type;
  339. }
  340. static Window get_daemon_window(Display *dpy)
  341. {
  342.   Window win, root_win;
  343.   XTextProperty wname;
  344.   Atom type;
  345.   int fmt;
  346.   unsigned long nitems, bytes_after;
  347.   unsigned char *prop;
  348.   root_win = DefaultRootWindow(dpy);
  349.   XGetWindowProperty(dpy, root_win, command_event, 0, 1, False, AnyPropertyType, &type, &fmt, &nitems, &bytes_after, &prop);
  350.   if(!prop) {
  351.     return 0;
  352.   }
  353.   win = *(Window*)prop;
  354.   XFree(prop);
  355.   if(!XGetWMName(dpy, win, &wname) || strcmp("Magellan Window", (char*)wname.value) != 0) {
  356.     return 0;
  357.   }
  358.   return win;
  359. }
  360. static int catch_badwin(Display *dpy, XErrorEvent *err)
  361. {
  362.   char buf[256];
  363.   if(err->error_code == BadWindow) {
  364.     /* do nothing? */
  365.   } else {
  366.     XGetErrorText(dpy, err->error_code, buf, sizeof buf);
  367.     fprintf(stderr, "Caught unexpected X error: %sn", buf);
  368.   }
  369.   return 0;
  370. }
  371. #endif  /* TARGET_HOST_POSIX_X11 */