diff options
| -rw-r--r-- | mariokart01.cpp | 156 | ||||
| -rw-r--r-- | mupen64plus-input-sdl.patch | 204 |
2 files changed, 340 insertions, 20 deletions
diff --git a/mariokart01.cpp b/mariokart01.cpp index 3eb5a73..f3e0039 100644 --- a/mariokart01.cpp +++ b/mariokart01.cpp @@ -20,6 +20,8 @@ */ +#define FREEBSD + #include <vector> #include <unistd.h> #include <stdio.h> @@ -29,6 +31,11 @@ #include <semaphore.h> #include <fcntl.h> +#ifdef LINUX +#include <linux/input.h> +#include <linux/uinput.h> +#endif + #include <errno.h> #include <sys/types.h> #include <sys/stat.h> @@ -224,7 +231,7 @@ void XorgGrabber::read(Mat& mat) #define THROTTLE_CNT_MAX 10 - +#ifdef FREEBSD typedef union { unsigned int Value; struct { @@ -280,12 +287,12 @@ char* pack(const BUTTONS* buttons, char* buf) return buf; } - +#endif class Joystick { public: - Joystick(const char* fifo); + Joystick(); void steer(float dir, float dead_zone=0.0); void throttle(float t); void press_a(bool); @@ -295,18 +302,21 @@ class Joystick void reset(); private: +#ifdef FREEBSD BUTTONS buttons; void send_data(); int fifo_fd; +#endif float throt; int throttle_cnt; }; -Joystick::Joystick(const char* fifo) +#ifdef FREEBSD +Joystick::Joystick() { - if ((fifo_fd=open(fifo, O_WRONLY )) == -1) {throw string(strerror(errno));} + if ((fifo_fd=open("/var/tmp/mupen64plus_ctl", O_WRONLY )) == -1) {throw string(strerror(errno));} cout << "opened" << endl; if (fcntl(fifo_fd, F_SETFL, O_NONBLOCK) == -1) throw string("failed to set nonblocking io"); @@ -339,6 +349,111 @@ void Joystick::steer(float dir, float dead_zone) send_data(); } +void Joystick::reset() +{ + memset(&buttons, sizeof(buttons), 0); + buttons.Z_TRIG=0; + buttons.R_TRIG=0; + buttons.L_TRIG=0; + buttons.A_BUTTON=0; + buttons.B_BUTTON=0; + send_data(); +} + +#endif +#ifdef LINUX +Joystick::Joystick() +{ + fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK); + if(fd < 0) { + cerr << "open uinput failed. do you have privilegies to access it? (try chown flo:root /dev/uinput)" << endl; + exit(EXIT_FAILURE); + } + + int ret; + + ret=ioctl(fd, UI_SET_EVBIT, EV_KEY); + ret=ioctl(fd, UI_SET_EVBIT, EV_SYN); + ret=ioctl(fd, UI_SET_KEYBIT , BTN_A); + ioctl(fd, UI_SET_EVBIT, EV_ABS); + ioctl(fd, UI_SET_ABSBIT, ABS_X); + ioctl(fd, UI_SET_ABSBIT, ABS_Y); + + struct uinput_user_dev meh; + memset(&meh,0,sizeof(meh)); + + strcpy(meh.name, "flotest"); + meh.id.bustype=BUS_USB; + meh.id.vendor=0xdead; + meh.id.product=0xbeef; + meh.id.version=1; + meh.absmin[ABS_X]=0; + meh.absmax[ABS_X]=10000; + meh.absmin[ABS_Y]=0; + meh.absmax[ABS_Y]=10000; + + + ret=write(fd, &meh, sizeof(meh)); + + ioctl(fd,UI_DEV_CREATE); + + reset(); +} + +Joystick::~Joystick() +{ + ioctl(fd, UI_DEV_DESTROY); + close(fd); +} + +void Joystick::steer(float dir, float dead_zone) +{ + if (dir<-1.0) dir=-1.0; + if (dir>1.0) dir=1.0; + + if (fabs(dir)<dead_zone) dir=0.0; + + struct input_event ev; + ev.type=EV_ABS; + ev.code=ABS_X; + ev.value=5000+dir*5000; + write(fd, &ev, sizeof(ev)); +} + + +void Joystick::press_a(bool a) +{ + struct input_event ev; + ev.type=EV_KEY; + ev.code=BTN_A; + ev.value = a ? 1 : 0; + write(fd, &ev, sizeof(ev)); +} + +void Joystick::reset() +{ + struct input_event ev; + ev.type=EV_ABS; + ev.code=ABS_Y; + ev.value=5001; + write(fd, &ev, sizeof(ev)); + ev.value=5000; + write(fd, &ev, sizeof(ev)); + + cout << "Y zeroed" << endl; + + steer(0.1); + steer(0); + cout << "X zeroed" << endl; + + press_a(true); + press_a(false); + cout << "A zeroed" << endl; +} + +#endif + + void Joystick::throttle(float t) { if (t<0.0) t=0.0; @@ -355,17 +470,6 @@ void Joystick::process() press_a((throttle_cnt < throt*THROTTLE_CNT_MAX)); } -void Joystick::reset() -{ - memset(&buttons, sizeof(buttons), 0); - buttons.Z_TRIG=0; - buttons.R_TRIG=0; - buttons.L_TRIG=0; - buttons.A_BUTTON=0; - buttons.B_BUTTON=0; - send_data(); -} - #define HIST_SMOOTH 7 @@ -534,14 +638,18 @@ try { string tmp; - +#ifdef LINUX + Joystick joystick; + cout << "joystick initalized, now starting mupen." << endl; +#endif if (fork()==0) { system("mupen64plus --nogui --noask ~/MarioKart64.rom"); exit(0); } +#ifdef FREEBSD sleep(2); + Joystick joystick; +#endif - Joystick joystick("/var/tmp/mupen64plus_ctl"); - sleep(1); joystick.reset(); @@ -577,9 +685,17 @@ try { cout << "waiting for game to start, press enter when started." << endl; joystick.press_a(false); + joystick.reset(); getchar(); - +joystick.reset(); +joystick.press_a(true); +getchar(); +#ifdef LINUX + XorgGrabber capture("glN64"); +#endif +#ifdef FREEBSD XorgGrabber capture("Mupen64Plus OpenGL Video"); +#endif int road_0=77, road_1=77, road_2=77; diff --git a/mupen64plus-input-sdl.patch b/mupen64plus-input-sdl.patch new file mode 100644 index 0000000..20e1f91 --- /dev/null +++ b/mupen64plus-input-sdl.patch @@ -0,0 +1,204 @@ +diff -ru mupen64plus-bundle-src-1.99.4-orig/source/mupen64plus-input-sdl/src/plugin.c mupen64plus-bundle-src-1.99.4/source/mupen64plus-input-sdl/src/plugin.c +--- mupen64plus-bundle-src-1.99.4-orig/source/mupen64plus-input-sdl/src/plugin.c 2012-11-20 20:38:20.000000000 +0100 ++++ mupen64plus-bundle-src-1.99.4/source/mupen64plus-input-sdl/src/plugin.c 2012-11-26 18:17:51.000000000 +0100 +@@ -24,6 +24,12 @@ + #include <stdio.h> + #include <stdlib.h> + #include <string.h> ++#include <errno.h> ++#include <fcntl.h> ++#include <unistd.h> ++#include <sys/types.h> ++#include <sys/stat.h> ++#include <sys/uio.h> + + #include <SDL.h> + +@@ -133,6 +139,151 @@ + + static CONTROL temp_core_controlinfo[4]; + ++/* FIFO-Control functions by flo */ ++static BUTTONS unpack_fifo_data(const char* buf) ++{ ++ BUTTONS buttons; ++ ++ buttons.A_BUTTON = (buf[0] & 1) ? 1 : 0; ++ buttons.B_BUTTON = (buf[0] & 2) ? 1 : 0; ++ buttons.L_TRIG = (buf[0] & 4) ? 1 : 0; ++ buttons.R_TRIG = (buf[0] & 8) ? 1 : 0; ++ buttons.Z_TRIG = (buf[0] & 16) ? 1 : 0; ++ buttons.START_BUTTON = (buf[0] & 32) ? 1 : 0; ++ buttons.R_DPAD = (buf[1] & 1) ? 1 : 0; ++ buttons.L_DPAD = (buf[1] & 2) ? 1 : 0; ++ buttons.U_DPAD = (buf[1] & 4) ? 1 : 0; ++ buttons.D_DPAD = (buf[1] & 8) ? 1 : 0; ++ buttons.R_CBUTTON = (buf[2] & 2) ? 1 : 0; ++ buttons.L_CBUTTON = (buf[2] & 4) ? 1 : 0; ++ buttons.U_CBUTTON = (buf[2] & 8) ? 1 : 0; ++ buttons.D_CBUTTON = (buf[2] & 16) ? 1 : 0; ++ ++ buttons.X_AXIS = buf[3] | ((buf[1] & 16) ? 128 : 0); ++ buttons.Y_AXIS = buf[4] | ((buf[1] & 32) ? 128 : 0); ++ ++ return buttons; ++} ++ ++typedef struct ++{ ++ int fd; ++ int good; ++ char buf[5]; ++ int bufptr; ++ int recovering; ++ BUTTONS buttons; ++ ++} ctl_fifo_t; ++ ++static ctl_fifo_t init_ctl_fifo(const char* path) ++{ ++ ctl_fifo_t ctl_fifo; ++ ctl_fifo.fd=-1; ++ ctl_fifo.good=0; ++ ctl_fifo.bufptr=0; ++ ctl_fifo.recovering=0; ++ ++ if (unlink(path) < 0) ++ if (errno!=ENOENT) ++ { ++ fprintf(stderr, "The control fifo (%s) could not be unlinked, continuing without remote control support: %s", path, strerror(errno)); ++ ctl_fifo.good=0; ++ return ctl_fifo; ++ } ++ ++ ++ if (mkfifo(path, S_IRWXU)!=0) ++ { ++ fprintf(stderr, "The control fifo (%s) could not be created, continuing without remote control support: %s", path, strerror(errno)); ++ ctl_fifo.good=0; ++ return ctl_fifo; ++ } ++ ++ if ((ctl_fifo.fd=open(path, O_RDONLY | O_NONBLOCK))<0) ++ { ++ fprintf(stderr, "The control fifo (%s) could not be opened, continuing without remote control support: %s", path, strerror(errno)); ++ ctl_fifo.good=0; ++ return ctl_fifo; ++ } ++ ++ if (fcntl(ctl_fifo.fd, F_SETFL, O_NONBLOCK)==-1) ++ { ++ fprintf(stderr, "Could not set nonblocking io mode on control fifo, continuing without remote control support: %s", strerror(errno)); ++ close(ctl_fifo.fd); ++ ctl_fifo.fd=-1; ++ ctl_fifo.good=0; ++ return ctl_fifo; ++ } ++ ++ ctl_fifo.good=1; ++ ++ return ctl_fifo; ++} ++ ++static BUTTONS read_buttons_from_fifo(ctl_fifo_t* ctl_fifo) ++{ ++ ssize_t bytes; ++ ++ if (ctl_fifo->recovering) ++ { ++ do ++ { ++ ctl_fifo->bufptr=0; ++ if ((bytes = read(ctl_fifo->fd, ctl_fifo->buf, 1)) == -1 && errno!=EAGAIN) ++ { ++ printf("read error!\n"); ++ } ++ ++ //if (bytes==1) printf("\tread %c\n", ctl_fifo->buf[0]); ++ } while ((ctl_fifo->buf[0] & 128)==0 && bytes>0); ++ ++ if (ctl_fifo->buf[0] & 128) ++ { ++ printf("successfully recovered :)\n"); ++ ctl_fifo->recovering=0; ++ ctl_fifo->bufptr=1; ++ } ++ } ++ ++ ++ if (!ctl_fifo->recovering) ++ do ++ { ++ if ((bytes = read(ctl_fifo->fd, ctl_fifo->buf+ctl_fifo->bufptr, sizeof(ctl_fifo->buf)-ctl_fifo->bufptr)) == -1 ++ && (errno!=EAGAIN)) ++ { ++ printf("read error!\n"); ++ } ++ else if (bytes>0) ++ { ++ ctl_fifo->bufptr+=bytes; ++ if (ctl_fifo->bufptr==sizeof(ctl_fifo->buf)) ++ { ++ ctl_fifo->bufptr=0; ++ ++ if (ctl_fifo->buf[0] & 128) ++ { ++ ctl_fifo->buttons = unpack_fifo_data(ctl_fifo->buf); ++ } ++ else ++ { ++ printf("fifo data corrupt, entering recovery mode\n"); ++ ctl_fifo->recovering=1; ++ break; ++ } ++ } ++ } ++ } while (bytes>0); ++ ++ return ctl_fifo->buttons; ++} ++ ++static ctl_fifo_t ctl_fifo; ++static int ctl_fifo_inited=0; ++static int ctl_fifo_takeover=0; ++ ++ + /* Mupen64Plus plugin functions */ + EXPORT m64p_error CALL PluginStartup(m64p_dynlib_handle CoreLibHandle, void *Context, + void (*DebugCallback)(void *, int, const char *)) +@@ -454,6 +605,12 @@ + SDL_Event event; + unsigned char mstate; + ++ if (ctl_fifo_inited==0) ++ { ++ ctl_fifo=init_ctl_fifo("/var/tmp/mupen64plus_ctl"); ++ ctl_fifo_inited=1; ++ } ++ + // Handle keyboard input first + doSdlKeys(SDL_GetKeyState(NULL)); + doSdlKeys(myKeyState); +@@ -596,7 +753,21 @@ + #ifdef _DEBUG + DebugMessage(M64MSG_VERBOSE, "Controller #%d value: 0x%8.8X\n", Control, *(int *)&controller[Control].buttons ); + #endif +- *Keys = controller[Control].buttons; ++ ++ if (Control==0) ++ { ++ BUTTONS fromfifo = read_buttons_from_fifo(&ctl_fifo); ++ if (fromfifo.A_BUTTON) ++ ctl_fifo_takeover=1; ++ ++ if (ctl_fifo_takeover) ++ *Keys = fromfifo; ++ else ++ *Keys = controller[Control].buttons; ++ ++ } ++ else ++ *Keys = controller[Control].buttons; + + /* handle mempack / rumblepak switching (only if rumble is active on joystick) */ + #ifdef __linux__ |