Commit: 2aff5840f06ea2008a09f02a351acc4ebc976eb1 - rejoy (git)

Lightweight cross-platform joystick input library

Commit MetaInfo

• Revision: 2aff5840f06ea2008a09f02a351acc4ebc976eb1 (tree)
• Zeit: 2021-06-12 07:15:08
• Autor: AlaskanEmily <emily@alas...>
• Commiter: AlaskanEmily

Log Message

Add Linux evdev backend.

Ändern Zusammenfassung

• modified: SConstruct
• add: evdev/Cargo.toml
• add: evdev/SConscript
• add: evdev/rejoy_evdev.cpp
• add: evdev/rejoy_evdev.hpp
• add: evdev/src/bitmap.rs
• add: evdev/src/gamepad.rs
• add: evdev/src/ioctl.rs
• add: evdev/src/lib.rs
• modified: rejoy.cpp
• modified: rejoy_demo.cpp
• add: unix/SConscript
• modified: unix/rejoy_unix_core.c
• modified: util/SConscript
• modified: util/rejoy_util.amd64.s
• modified: util/rejoy_util.c
• modified: util/rejoy_util.x86.s

Diff

--- a/SConstruct
+++ b/SConstruct
@@ -5,6 +5,13 @@ import os
 import sys
 import glob
 
+def GetLinkableLibrary(lib):
+    if os.name == 'nt':
+        if len(lib) == 1:
+            return lib[0]
+        else:
+            return lib[1]
+
 AddOption('--target', dest = 'target', nargs=1, action='store', help =
 "Override target architecture.")
 
@@ -26,6 +33,9 @@ AddOption('--enable-dinput', dest = 'enable-dinput', nargs=1, action='store', he
 AddOption('--enable-bsd', dest = 'enable-bsd', nargs=1, action='store', help =
 "Use the BSD backend libusbhid, enabled by default on BSD systems")
 
+AddOption('--enable-evdev', dest = 'enable-evdev', nargs=1, action='store', help =
+"Use the evdev backend, enabled by default on Linux and FreeBSD systems")
+
 AddOption('--build-shared', dest = 'build-shared', nargs=1, action='store', help =
 "Build shared library, disabled by default.")
 
@@ -57,6 +67,7 @@ def DefaultDriverOption(Driver, Default):
 DefaultDriverOption('xinput', os.name == 'nt')
 DefaultDriverOption('dinput', os.name == 'nt')
 DefaultDriverOption('bsd', 'bsd' in sys.platform.lower())
+DefaultDriverOption('evdev', 'freebsd' in sys.platform.lower() or 'linux' in sys.platform.lower())
 
 if os.name == 'nt':
     rejoy_build_shared = True
@@ -73,66 +84,77 @@ if GetOption('build-shared-modules') == 'y':
 else:
     rejoy_build_shared_modules = False
 
+if rejoy_build_shared:
+    if os.name == 'nt':
+        environment.Append(CPPDEFINES=["REJOY_INTERNAL_DLL=1"])
+    environment.Append(CPPDEFINES=["REJOY_SHARED=1"])
+else:
+    environment.Append(CPPDEFINES=["REJOY_SHARED=0"])
+
 rejoy_util = SConscript(dirs=["util"], exports=["CC", "environment"])
 
 environment.Append(CPPPATH=os.path.join(os.getcwd(), "util"))
 
 # Default source
 rejoy_source = ["rejoy.cpp", "rejoy_c.cpp"]
-rejoy_libs = [rejoy_util]
+rejoy_libs = []
 
 # Dict of libraries indexed by driver backend.
 rejoy_lib_dict = {
     "dinput":["dinput8", "dxguid.lib", "user32"],
     "xinput":["xinput"],
-    "bsd":["usbhid"]
+    "bsd":["usbhid"],
+    "evdev":["dl", "pthread"]
 }
 
 # Drivers which require the Unix source to be included.
-rejoy_unix_drivers = [
+rejoy_unix_drivers = (
     "bsd",
     "joy",
-    "linux"
-]
+    "evdev"
+)
 
 # Add up the drivers, also checking for requirement of unix.
 use_unix = False
 for driver in rejoy_drivers:
-    if driver in rejoy_lib_dict:
-        rejoy_libs += rejoy_lib_dict[driver]
     if driver in rejoy_unix_drivers:
         use_unix = True
+        break
+
+if use_unix:
+    rejoy_unix = SConscript(dirs=["unix"], exports=["environment"])
+
+depends_on_unix = []
+for driver in rejoy_drivers:
+    if driver in rejoy_lib_dict:
+        rejoy_libs += rejoy_lib_dict[driver]
     # Check if there is a SConscript file to read or not.
     if os.path.isfile(os.path.join(driver, "SConscript")):
-        rejoy_libs.append(SConscript(dirs=[driver], exports=["CC", "environment", "rejoy_build_shared"]))
+        lib = SConscript(dirs=[driver], exports=["CC", "environment", "rejoy_build_shared"])
+        rejoy_libs.append(lib)
+        if driver in rejoy_unix_drivers:
+            environment.Depends(lib, rejoy_unix)
+            environment.Depends(lib, rejoy_util)
     else:
         rejoy_source += glob.glob(os.path.join(driver, "*.cpp"))
         rejoy_source += glob.glob(os.path.join(driver, "*.c"))
     environment.Append(CPPDEFINES=["REJOY_DRIVER_" + driver.upper() + "=1"])
 
+rejoy_dep_libs = rejoy_libs + [rejoy_util]
 if use_unix:
-    rejoy_source += glob.glob(os.path.join("unix", "*.cpp"))
-    rejoy_source += glob.glob(os.path.join("unix", "*.c"))
+    rejoy_dep_libs.append(rejoy_unix)
 
 if rejoy_build_shared:
-    if os.name == 'nt':
-        environment.Append(CPPDEFINES=["REJOY_INTERNAL_DLL=1"])
-    environment.Append(CPPDEFINES=["REJOY_SHARED=1"])
-    rejoy = environment.SharedLibrary('rejoy', rejoy_source, LIBS=rejoy_libs)
+    rejoy = environment.SharedLibrary('rejoy', rejoy_source, LIBS=rejoy_dep_libs)
 else:
-    environment.Append(CPPDEFINES=["REJOY_SHARED=0"])
-    rejoy = environment.StaticLibrary('rejoy', rejoy_source, LIBS=rejoy_libs)
-
-if os.name == 'nt':
-    if len(rejoy) == 1:
-        rejoy = rejoy[0]
-    else:
-        rejoy = rejoy[1]
+    rejoy = environment.StaticLibrary('rejoy', rejoy_source, LIBS=rejoy_dep_libs)
 
-demo_libs = [rejoy]
 if not rejoy_build_shared:
-    demo_libs += rejoy_libs
-
+    demo_libs = [rejoy] + rejoy_libs + [rejoy_util]
+    if use_unix:
+        demo_libs.append(rejoy_unix)
+else:
+    demo_libs = [rejoy]
 
 demo = environment.Program(['rejoy_demo.cpp'],  LIBS=demo_libs)
 

--- /dev/null
+++ b/evdev/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "rejoy_evdev"
+version = "0.0.1"
+authors = ["AlaskanEmily"]
+
+[dependencies]
+ioctl-sys = "0.7.*"
+
+[lib]
+crate-type = ["staticlib", "cdylib"]
+

--- /dev/null
+++ b/evdev/SConscript
@@ -0,0 +1,65 @@
+# Any copyright is dedicated to the Public Domain.
+# http://creativecommons.org/publicdomain/zero/1.0/
+import os
+import glob
+
+Import("environment rejoy_build_shared")
+
+# We use cxxflags.txt as a pseudo-source.
+# This is used by both Cargo and SCons to force a rebuild if CXXFLAGS change.
+# It might be possible to avoid this if we could build the shim within SCons,
+# however since it requires some files generated by the Rust build script we
+# would need to invoke the Rust build process multiple times.
+#
+# This also allows us to (potentially) parse the args here in Python and then
+# give them as line-separated strings to Rust, then std::process::Command::args
+# will properly understand them.
+
+env = os.environ
+
+# Set the CXX/CC value to be consumed by Cargo
+env["CXX"] = str(environment["CXX"])
+env["CC"] = str(environment["CC"])
+
+# Pass the location of rejoy_util in an environment variable.
+
+DELIMIT = '\n'
+CXXFLAGSPATH = "cxxflags.txt"
+
+# Write the CXX flags, if they have changed.
+cxxflags_file = None
+try:
+    cxxflags_file = open(CXXFLAGSPATH, "r")
+    cxxflags = cxxflags.read()
+except:
+    cxxflags = ""
+finally:
+    if cxxflags_file:
+        cxxflags_file.close()
+
+# Construct the new flags
+new_cxxflags = str(environment["CXXFLAGS"]).split()
+if rejoy_build_shared and "-fPIC" not in new_cxxflags and "-fpic" not in new_cxxflags:
+    new_cxxflags.append("-fPIC")
+old_cxxflags = cxxflags.split(DELIMIT)
+
+if new_cxxflags != old_cxxflags:
+    cxxflags_file = open(CXXFLAGSPATH, "w")
+    cxxflags_file.write(DELIMIT.join(new_cxxflags))
+    cxxflags_file.close()
+
+rust_lib="librejoy_evdev" + environment['LIBSUFFIX']
+src = []
+
+for s in ("rejoy_evdev.hpp", "rejoy_evdev.cpp", "build.rs", CXXFLAGSPATH):
+    src.append(os.path.join(os.getcwd(), s))
+for s in glob.glob("Cargo.*") + glob.glob("src/*.rs"):
+    src.append(os.path.join(os.getcwd(), s))
+
+rejoy_evdev_rs = environment.Command(
+    target=os.path.join(os.getcwd(), "target", "debug", rust_lib),
+    source=src,
+    action="cargo build",
+    chdir=os.getcwd())
+
+Return("rejoy_evdev_rs")

--- /dev/null
+++ b/evdev/rejoy_evdev.cpp
@@ -0,0 +1,122 @@
+// Copyright (c) 2021 Alaskan Emily, Transnat Games
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include "rejoy_evdev.hpp"
+#include "../rejoy_private.hpp"
+#include "../unix/rejoy_unix_core.h"
+#include <unistd.h>
+#include <fcntl.h>
+
+///////////////////////////////////////////////////////////////////////////////
+// Manual bindings. These are irregular, one-off functions.
+extern "C" {
+
+///////////////////////////////////////////////////////////////////////////////
+// Gamepads functions
+struct Rejoy_Evdev_Gamepad *Rejoy_Evdev_OpenGamepad(int fd);
+struct Rejoy_Evdev_Gamepad *Rejoy_Evdev_CopyGamepad(
+    const struct Rejoy_Evdev_Gamepad *data);
+void Rejoy_Evdev_FinalizeGamepad(struct Rejoy_Evdev_Gamepad *data);
+void Rejoy_Evdev_UpdateGamepad(struct Rejoy_Evdev_Gamepad *data, int fd);
+
+///////////////////////////////////////////////////////////////////////////////
+// Rust Vec bindings.
+void *Rejoy_Evdev_VecAppend(void *vec, void *val);
+unsigned Rejoy_Evdev_VecGetLen(const void *vec);
+Rejoy::EvdevGamepad *Rejoy_Evdev_VecGetValue(void *vec, unsigned i);
+void Rejoy_Evdev_FinalizeVec(void *vec);
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // extern "C
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace Rejoy {
+
+///////////////////////////////////////////////////////////////////////////////
+
+static inline void DeleteGamepads(void *vec) {
+    const unsigned len = Rejoy_Evdev_VecGetLen(vec);
+    for(unsigned i = 0; i < len; i++){
+        delete Rejoy_Evdev_VecGetValue(vec, i);
+    }
+    Rejoy_Evdev_FinalizeVec(vec);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+EvdevGamepad::EvdevGamepad(const EvdevGamepad &other)
+  : UnixGamepad(other)
+  , m_data(Rejoy_Evdev_CopyGamepad(other.m_data)) {}
+
+///////////////////////////////////////////////////////////////////////////////
+
+EvdevGamepad::~EvdevGamepad() {
+    Rejoy_Evdev_FinalizeGamepad(m_data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void EvdevGamepad::update() {
+    Rejoy_Evdev_UpdateGamepad(m_data, fd());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void EvdevDriver::enumerateGamepad(int fd){
+    // TODO: This could be handled totally on the Rust side pretty easily.
+    if(m_num_gamepads)
+        return;
+    if(struct Rejoy_Evdev_Gamepad *const data = Rejoy_Evdev_OpenGamepad(fd)){
+        EvdevGamepad *const gamepad = new EvdevGamepad(fd, data);
+        m_gamepad_list = Rejoy_Evdev_VecAppend(m_gamepad_list, gamepad);
+        m_num_gamepads++;
+    }
+    else{
+        // close(fd);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+EvdevDriver::~EvdevDriver() {
+    DeleteGamepads(m_gamepad_list);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void EvdevDriver::update() {
+    DeleteGamepads(m_gamepad_list);
+    m_gamepad_list = NULL;
+    m_num_gamepads = 0;
+    Rejoy_Unix_IterateGlob("/dev/input/event*",
+        O_RDWR | O_NONBLOCK,
+        this,
+        EvdevDriver::EnumateGamepad);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+Gamepad *EvdevDriver::getGamepad(unsigned i) {
+    if(i < Rejoy_Evdev_VecGetLen(m_gamepad_list)){
+        Gamepad *gamepad = Rejoy_Evdev_VecGetValue(m_gamepad_list, i);
+        return gamepad;
+    }
+    else
+        return NULL;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+REJOY_STATIC_INIT(Evdev);
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace Rejoy
+
+///////////////////////////////////////////////////////////////////////////////
+

--- /dev/null
+++ b/evdev/rejoy_evdev.hpp
@@ -0,0 +1,81 @@
+// Copyright (c) 2021 Alaskan Emily, Transnat Games
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef REJOY_EVDEV_HPP
+#define REJOY_EVDEV_HPP
+#pragma once
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include "../rejoy.hpp"
+#include "../unix/rejoy_unix.hpp"
+#include "rejoy_evdev_bind.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+namespace Rejoy {
+
+///////////////////////////////////////////////////////////////////////////////
+// Tagged as struct so that it can be used in SLIST's
+class EvdevGamepad : public Rejoy::UnixGamepad {
+    struct Rejoy_Evdev_Gamepad *const m_data;
+public:
+    inline EvdevGamepad(int fd, struct Rejoy_Evdev_Gamepad *data)
+      : UnixGamepad(fd,
+            Rejoy_Evdev_GetNumAxes(data),
+            Rejoy_Evdev_GetNumButtons(data),
+            Rejoy_Evdev_GetNumHats(data))
+      , m_data(data) {}
+    
+    explicit EvdevGamepad(const EvdevGamepad &other);
+    
+    ~EvdevGamepad();
+    
+    virtual void update();
+    virtual const char *name() const {
+        return Rejoy_Evdev_GetName(m_data);
+    }
+    virtual short getAxis(unsigned i) const {
+        return Rejoy_Evdev_GetAxis(m_data, i);
+    }
+    virtual bool getButton(unsigned i) const {
+        return Rejoy_Evdev_GetButton(m_data, i);
+    }
+    virtual unsigned getHat(unsigned i) const {
+        return Rejoy_Evdev_GetHat(m_data, i);
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class EvdevDriver : public Rejoy::Driver {
+    // A Rust slice of EvdevGamepad.
+    void *m_gamepad_list;
+
+    void enumerateGamepad(int fd);
+    static void EnumateGamepad(void *that, const char *name, int fd){
+        (void)name;
+        static_cast<EvdevDriver*>(that)->enumerateGamepad(fd);
+    }
+public:
+    EvdevDriver()
+      : Driver("evdev")
+      , m_gamepad_list(NULL) {}
+    
+    ~EvdevDriver();
+    
+    virtual void update();
+    virtual Gamepad *getGamepad(unsigned i);
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+} // namespace Rejoy
+
+///////////////////////////////////////////////////////////////////////////////
+
+#endif // REJOY_EVDEV_HPP
+

--- /dev/null
+++ b/evdev/src/bitmap.rs
@@ -0,0 +1,325 @@
+use std::{fmt, iter};
+
+/// Bitmap container type with a fixed size and variable bit length elements.
+/// TODO: This is clearly not optimal.
+
+pub trait Bitmap {
+    fn get_bit(&self, i: usize) -> u8;
+    fn set_bit(&mut self, i: usize, val: u8) -> bool;
+    fn as_ptr(&self) -> *const u8;
+    fn as_mut_ptr(&mut self) -> *mut u8;
+    fn element_size(&self) -> usize;
+    fn len(&self) -> usize;
+}
+
+#[inline]
+pub fn get_slice<B>(b: &B, i: usize) -> u32
+where
+    B: Bitmap
+{
+    let mut n: u32 = 0;
+    let esize = b.element_size();
+    let base = i * esize;
+    for e in  0 .. esize {
+        n |= (b.get_bit(base + e) as u32) << e;
+    }
+    n
+}
+
+#[inline]
+pub fn set_slice<B>(b: &mut B, i: usize, val: u32)
+where
+    B: Bitmap
+{
+    let esize = b.element_size();
+    let base = i * esize;
+    for e in  0 .. esize {
+        b.set_bit(base + e, (val >> e) as u8 & 1);
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct BitmapRef<B>(pub B, pub usize);
+
+impl<B> BitmapRef<B> {
+    #[inline]
+    pub fn new(that: B) -> Self {
+        BitmapRef(that, 0)
+    }
+}
+
+
+impl<'a, B> BitmapRef<&'a B>
+where
+    B: Bitmap
+{
+    #[inline]
+    pub fn get(&self) -> u32 {
+        get_slice(self.0, self.1)
+    }
+    
+    #[inline]
+    pub fn end(&self) -> bool {
+        self.0.len() < self.1
+    }
+    
+    #[inline]
+    pub fn step(&mut self, n: usize) {
+        self.1 = std::cmp::min(self.1 + n, self.0.len());
+    }
+}
+
+impl<'a, B> BitmapRef<&'a mut B>
+where
+    B: Bitmap
+{
+    #[inline]
+    pub fn get(&self) -> u32 {
+        get_slice(self.0, self.1)
+    }
+    
+    #[inline]
+    pub fn end(&self) -> bool {
+        self.0.len() < self.1
+    }
+    
+    #[inline]
+    pub fn step(&mut self, n: usize) {
+        self.1 = std::cmp::min(self.1 + n, self.0.len());
+    }
+}
+
+impl<'a, B> BitmapRef<&'a mut B>
+where
+    B: Bitmap
+{
+    pub fn set(&mut self, val: u32) {
+        set_slice(self.0, self.1, val)
+    }
+}
+
+impl<'a, B> iter::Iterator for BitmapRef<&'a B>
+where
+    B: Bitmap
+{
+    type Item = u32;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.0.len() - 1 {
+            None
+        }
+        else{
+            let u = self.get();
+            self.step(1);
+            Some(u)
+        }
+    }
+    #[inline]
+    fn count(self) -> usize {
+        self.0.len() - self.1
+    }
+    
+    #[inline]
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        self.step(n);
+        self.next()
+    }
+}
+
+impl<'a, B> iter::Iterator for BitmapRef<&'a mut B>
+where
+    B: Bitmap
+{
+    type Item = u32;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.0.len() - 1 {
+            None
+        }
+        else{
+            let u = self.get();
+            self.step(1);
+            Some(u)
+        }
+    }
+    #[inline]
+    fn count(self) -> usize {
+        self.0.len() - self.1
+    }
+    
+    #[inline]
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        self.step(n);
+        self.next()
+    }
+}
+
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct BitmapIterator<B, T>(BitmapRef<B>, std::marker::PhantomData<T>);
+
+impl<B, T> BitmapIterator<B, T> {
+    #[inline]
+    pub fn new(that: B) -> Self {
+        BitmapIterator(BitmapRef::new(that), std::marker::PhantomData)
+    }
+}
+
+impl<B, T> std::convert::From<BitmapRef<B>> for BitmapIterator<B, T> {
+    #[inline]
+    fn from(that: BitmapRef<B>) -> Self {
+        BitmapIterator(that, std::marker::PhantomData)
+    }
+}
+
+impl<'a, B, T> BitmapIterator<&'a B, T>
+where
+    B: Bitmap,
+    T: From<u32>,
+{
+    #[inline]
+    pub fn get_val(&self) -> T {
+        self.0.get().into()
+    }
+}
+
+impl<'a, B, T> BitmapIterator<&'a mut B, T>
+where
+    B: Bitmap,
+    T: From<u32>,
+{
+    #[inline]
+    pub fn get_val(&self) -> T {
+        self.0.get().into()
+    }
+}
+
+impl<'a, B, T> BitmapIterator<&'a mut B, T>
+where
+    B: Bitmap,
+    T: Into<u32>,
+{
+    #[inline]
+    pub fn set_val(&mut self, val: T) {
+        self.0.set(val.into());
+    }
+}
+
+impl <'a, B, T> iter::Iterator for BitmapIterator<&'a B, T>
+where
+    B: Bitmap,
+    T: From<u32>,
+{
+    type Item = T;
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next().map(|a| a.into())
+    }
+    #[inline]
+    fn count(self) -> usize {
+        self.0.count()
+    }
+}
+
+impl <'a, B, T> iter::Iterator for BitmapIterator<&'a mut B, T>
+where
+    B: Bitmap,
+    T: From<u32>,
+{
+    type Item = T;
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next().map(|a| a.into())
+    }
+    #[inline]
+    fn count(self) -> usize {
+        self.0.count()
+    }
+}
+
+impl fmt::Display for dyn Bitmap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let esize = self.element_size();
+        f.write_str("{")?;
+        for i in 0 .. self.len() {
+            f.write_str("0b")?;
+            for e in 0 .. esize {
+                f.write_str(
+                    match self.get_bit(e + (i * esize)) {
+                        0 => "0",
+                        _ => "1",
+                    })?;
+            }
+            f.write_str(",")?;
+        }
+        Ok(())
+    }
+}
+
+macro_rules! bitmap_size {
+    ($esize:expr, $count:expr) => { ((($esize * $count) + 7) / 8) as usize }
+}
+
+macro_rules! bitmap {
+    ($name:ident [ $esize:expr ; $count:expr ] ) => {
+        
+        #[derive(Clone, PartialEq, Debug)]
+        #[repr(transparent)]
+        pub struct $name([u8; bitmap_size!($esize, $count)]);
+
+        impl $name {
+            #[inline]
+            pub fn new() -> Self {
+                $name([0; bitmap_size!($esize, $count)])
+            }
+            #[inline]
+            pub fn iter<'a>(&'a self) -> crate::bitmap::BitmapRef<&'a Self> {
+                crate::bitmap::BitmapRef(self, 0)
+            }
+            #[inline]
+            pub fn iter_mut<'a>(&'a mut self) -> crate::bitmap::BitmapRef<&'a mut Self> {
+                crate::bitmap::BitmapRef(self, 0)
+            }
+            #[inline]
+            pub fn ptr_size() -> usize { bitmap_size!($esize, $count) }
+        }
+        
+        impl Default for $name {
+            #[inline]
+            fn default() -> Self { $name::new() }
+        }
+        
+        impl crate::bitmap::Bitmap for $name {
+            #[inline]
+            fn get_bit(&self, i: usize) -> u8 {
+                (self.0[i >> 3] >> (i & 7)) & 1
+            }
+            fn set_bit(&mut self, i: usize, val: u8) -> bool {
+                let mask = 1 << (i & 7);
+                let old = (self.0[i >> 3] & mask) != 0;
+                if val != 0 {
+                    self.0[i >> 3] |= mask;
+                }
+                else{
+                    self.0[i >> 3] &= !mask;
+                }
+                old
+            }
+            #[inline]
+            fn element_size(&self) -> usize { $esize }
+            #[inline]
+            fn len(&self) -> usize { $count }
+            #[inline]
+            fn as_ptr(&self) -> *const u8 { self.0.as_ptr() }
+            #[inline]
+            fn as_mut_ptr(&mut self) -> *mut u8 { self.0.as_mut_ptr() }
+        }
+        
+        impl<'a> std::iter::IntoIterator for &'a $name {
+            type Item = u32;
+            type IntoIter = crate::bitmap::BitmapRef<Self>;
+            fn into_iter(self) -> Self::IntoIter {
+                crate::bitmap::BitmapRef(self, 0)
+            }
+        }
+    }
+}
+

--- /dev/null
+++ b/evdev/src/gamepad.rs
@@ -0,0 +1,312 @@
+use std::cmp;
+use std::ffi::CString;
+use std::fs::File;
+use std::io::{self, Read};
+use std::vec::Vec;
+use ioctl::{self, AbsInfo, AbsValue};
+use bitmap::{Bitmap, BitmapIterator};
+use std::os::unix::io::RawFd as Fd;
+use std::os::unix::io::{IntoRawFd, FromRawFd};
+
+// Generated bindings
+include!{concat!(env!("OUT_DIR"), "/rejoy_evdev_bind.rs")}
+
+extern "C" {
+// For consistency with other drivers, use the same scaling function.
+fn Rejoy_ScaleValue(from: i32, to: i32, t: i32) -> i32;
+}
+
+macro_rules! btn_ranges {
+    ($($name:ident : $start:literal .. $end:literal,)*) => {
+        $(
+            const $name: std::ops::Range<u16> = std::ops::Range {
+                start: $start,
+                end: $end,
+            };
+        )*
+        const TOTAL_BTN_COUNT: usize = 0 $( + $end - $start )*;
+        #[inline]
+        fn for_each_btn<F>(mut op: F)
+        where
+            F: FnMut(u16)
+        {
+            $(
+                for i in $name {
+                    op(i);
+                }
+            )*
+        }
+    }
+}
+
+// Ranges of useful BTN values.
+btn_ranges!(
+    BTN_JOYSTICK: 0x120 .. 0x130,
+    BTN_GAMEPAD: 0x130 .. 0x13F,
+    BTN_WHEEL: 0x150 .. 0x152,
+    );
+
+const REJOY_C_TIMEVAL_SIZE: usize = super::REJOY_C_TIMEVAL_SIZE as usize;
+const INPUT_EVENT_SIZE: usize = REJOY_C_TIMEVAL_SIZE + 8;
+
+#[derive(Debug)]
+#[repr(C)]
+struct InputEvent {
+    time: [u8; REJOY_C_TIMEVAL_SIZE],
+    typ: u16,
+    code: u16,
+    value: i32,
+}
+
+#[derive(Clone, PartialEq, Debug)]
+struct AbsPair(AbsValue, AbsInfo);
+
+// TODO: This will be used when we handle SYN_DROPPED.
+/*
+impl AbsPair {
+    #[inline]
+    fn update(&mut self, fd: Fd) {
+        if let Ok(info) = ioctl::evdev_get_abs(fd, self.0) {
+            self.1 = info
+        }
+    }
+    #[inline]
+    fn value<'a>(&'a self) -> &'a AbsInfo {
+        &self.1
+    }
+}
+*/
+
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
+struct Button(u8);
+
+const REJOY_MAX_BUTTONS: usize = super::REJOY_MAX_BUTTONS as usize;
+const SOME_BUTTON: Button = Button(2);
+const NONE_BUTTON: Button = Button(0);
+
+impl Button {
+    #[inline]
+    fn present(&self) -> bool {
+        (self.0 & 2) != 0
+    }
+    #[inline]
+    fn value(&self) -> bool {
+        (self.0 & 1) != 0
+    }
+    #[inline]
+    fn update(&mut self, val: bool) {
+        self.0 = if val { self.0 | 1 } else { self.0 & 2 };
+    }
+}
+
+impl std::convert::From<u32> for Button {
+    #[inline]
+    fn from(that: u32) -> Self {
+        Button(that as u8)
+    }
+}
+
+impl std::convert::From<Button> for u32 {
+    #[inline]
+    fn from(that: Button) -> Self {
+        that.0 as u32
+    }
+}
+
+bitmap!{ Buttons [2; TOTAL_BTN_COUNT] }
+
+/*
+#[inline]
+fn cmp_abs_pair<T>(a: &(AbsValue, T), b: &(AbsValue, T)) -> std::cmp::Ordering {
+    AbsValue::cmp(a, b)
+}
+*/
+
+#[derive(Clone, PartialEq, Debug)]
+pub struct Gamepad {
+    name: CString,
+    axes: Vec<(AbsValue, AbsInfo)>,
+    hats: Vec<(AbsValue, AbsInfo)>,
+    buttons: Buttons,
+}
+
+impl Gamepad {
+    fn open(fd: Fd) -> io::Result<Self> {
+        let name = CString::new(ioctl::evdev_get_name(fd)?)?;
+        let mut hats = Vec::new();
+        let mut axes = Vec::new();
+        ioctl::AbsValue::for_each(|a|
+            if let Ok(info) = ioctl::evdev_get_abs(fd, a) {
+                if info.min == info.max {
+                    return; // Not an interesting axis.
+                }
+                if a.is_hat() {
+                    hats.push((a, info));
+                }
+                else if a.is_axis() {
+                    axes.push((a, info));
+                }
+            });
+        if hats.is_empty() && axes.is_empty() {
+            Err(io::Error::new(io::ErrorKind::Other, "Not a gamepad/joystick"))
+        }
+        else{
+            // Test for buttons.
+            let mut buttons = Buttons::new();
+            let mut button_iter = buttons.iter_mut();
+            if let Ok(button_test) = ioctl::evdev_get_btn(fd) {
+                for_each_btn(|i| {
+                    let bit = button_test.get_bit(i as usize);
+                    let b = if bit != 0 { SOME_BUTTON } else { NONE_BUTTON };
+                    button_iter.set(b.into());
+                    button_iter.step(1);
+                });
+            }
+            Ok( Gamepad{ name, axes, hats, buttons } )
+        }
+    }
+    fn button_iter<'a>(&'a self) -> BitmapIterator<&'a Buttons, Button> {
+        BitmapIterator::<&'a Buttons, Button>::new(&self.buttons)
+    }
+    fn button_iter_mut<'a>(&'a mut self) -> BitmapIterator<&'a mut Buttons, Button> {
+        BitmapIterator::<&'a mut Buttons, Button>::new(&mut self.buttons)
+    }
+    fn get_button(&self, i: usize) -> bool {
+        self.button_iter().filter(|b| b.present()).nth(i).map(|b| b.value()).unwrap_or(false)
+    }
+    #[inline]
+    fn get_num_buttons(&self) -> usize {
+        let n = self.button_iter().filter(|b| b.present()).count();
+        cmp::min(n, REJOY_MAX_BUTTONS)
+    }
+    #[inline]
+    fn get_axis(&self, i: usize) -> i16 {
+        let info = self.axes[i].1;
+        unsafe { Rejoy_ScaleValue(info.min, info.max, info.value) as i16 }
+    }
+    #[inline]
+    fn get_num_axes(&self) -> usize { self.axes.len() }
+    #[inline]
+    fn get_hat(&self, _i: usize) -> u32 {
+        0
+    }
+    #[inline]
+    fn get_num_hats(&self) -> usize { self.hats.len() }
+    fn update(&mut self, fd: Fd) {
+        assert!(std::mem::size_of::<InputEvent>() == INPUT_EVENT_SIZE);
+        let mut f = unsafe { File::from_raw_fd(fd) };
+        let mut buffer: [u8; INPUT_EVENT_SIZE] = [0; INPUT_EVENT_SIZE];
+        
+        // Read as many events as possible.
+        let mut result = f.read(&mut buffer);
+        while let Ok(INPUT_EVENT_SIZE) = result {
+            let event_ptr = buffer.as_ptr() as *const InputEvent;
+            let event = unsafe{ &*event_ptr };
+            match event.typ {
+                ioctl::EV_KEY => {
+                    let mut button_iter = self.button_iter_mut();
+                    for_each_btn(|i| {
+                        if i == event.code {
+                            let mut b = button_iter.get_val();
+                            if !b.present() {
+                                if cfg!(debug_assertions) {
+                                    eprintln!("Invalid button {} set", i);
+                                }
+                            }
+                            else {
+                                b.update(event.value != 0);
+                            }
+                            button_iter.set_val(b.into());
+                        }
+                        button_iter.next();
+                    });
+                },
+                ioctl::EV_MSC => {
+                    // println!("{:?}", event);
+                },
+                ioctl::EV_ABS => {
+                    let a = ioctl::ABS_VALUE_INT[event.code as usize];
+                    if a.is_hat() {
+                        if let Some(mut abspair) = self.hats.iter_mut().find(|p| p.0 == a) {
+                            abspair.1.value = event.value;
+                        }
+                    }
+                    else if a.is_axis() {
+                        if let Some(mut abspair) = self.axes.iter_mut().find(|p| p.0 == a) {
+                            abspair.1.value = event.value;
+                        }
+                    }
+                    else if cfg!(debug_assertions) {
+                        eprintln!("Unexpected ABS type {}", a);
+                    }
+                },
+                ioctl::EV_SYN => {
+                    // TODO: We should do a full re-read of the gamepad's
+                    // state when we get SYN_DROPPED.
+                },
+                _ => {
+                    if cfg!(debug_assertions) {
+                        eprintln!("Unkown event type {}", event.typ);
+                    }
+                },
+            }
+            result = f.read(&mut buffer);
+        }
+        // Drop the file descriptor again.
+        f.into_raw_fd();
+
+        if !cfg!(debug_assertions) {
+            return;
+        }
+        
+        match result {
+            Ok(len) =>
+                if len != INPUT_EVENT_SIZE && len != 0 {
+                    eprintln!("Invalid read size {}", len);
+                },
+            Err(e) =>
+                if e.kind() != io::ErrorKind::WouldBlock {
+                    eprintln!("{} err: {}", fd, e);
+                },
+        }
+    }
+}
+
+#[allow(non_camel_case_types)]
+type Rejoy_Evdev_Gamepad = Gamepad;
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Rejoy_Evdev_OpenGamepad(fd: Fd) -> *mut Gamepad {
+    match Gamepad::open(fd) {
+        Ok(gamepad) => {
+                let gamepad_box = Box::new(gamepad);
+                Box::leak(gamepad_box) as *mut Gamepad
+            },
+        Err(e) => {
+                if cfg!(debug_assertions) { eprintln!("Could not open gamepad: {}", e); }
+                std::ptr::null_mut()
+            },
+    }
+}
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Rejoy_Evdev_CopyGamepad(gamepad_ptr: *const Gamepad) -> *mut Gamepad {
+    let gamepad = unsafe { (*gamepad_ptr).clone() };
+    let gamepad_box = Box::new(gamepad);
+    Box::leak(gamepad_box) as *mut Gamepad
+}
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub unsafe extern "C" fn Rejoy_Evdev_FinalizeGamepad(gamepad_ptr: *mut Gamepad) {
+    let _ = Box::from_raw(gamepad_ptr);
+}
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub unsafe extern "C" fn Rejoy_Evdev_UpdateGamepad(gamepad_ptr: *mut Gamepad, fd: Fd) {
+    (*gamepad_ptr).update(fd);
+}
+

--- /dev/null
+++ b/evdev/src/ioctl.rs
@@ -0,0 +1,272 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+//! ioctl glue for using evdev.
+
+use ioctl_sys;
+
+use bitmap::Bitmap;
+
+use std::default::Default;
+use std::{io, fmt};
+use std::os::unix::io::RawFd as Fd;
+
+pub const KEY_MAX: u32 = 0x3FF;
+pub const KEY_CNT: usize = KEY_MAX as usize + 1;
+#[allow(unused)]
+pub const SYN_REPORT: u16 = 0;
+#[allow(unused)]
+pub const SYN_CONFIG: u16 = 1;
+#[allow(unused)]
+pub const SYN_DROPPED: u16 = 3;
+pub const EV_SYN: u16 = 0;
+pub const EV_KEY: u16 = 1;
+#[allow(unused)]
+pub const EV_REL: u16 = 2;
+pub const EV_ABS: u16 = 3;
+pub const EV_MSC: u16 = 4;
+#[allow(unused)]
+pub const EV_SW: u16 = 5;
+#[allow(unused)]
+pub const EV_LED: u16 = 17;
+#[allow(unused)]
+pub const EV_FF: u16 = 31;
+
+
+bitmap!{ Buttons [1; KEY_CNT] }
+
+#[derive(PartialEq, Eq, Clone, PartialOrd, Ord)]
+#[allow(non_camel_case_types, unused)]
+pub enum AbsAxisDir { x, y, other }
+#[derive(PartialEq, Eq, Clone, PartialOrd, Ord)]
+#[allow(non_camel_case_types, unused)]
+pub enum AbsAxisType { hat, stick, slider, other }
+
+macro_rules! abs_attribute {
+    ($func:ident $what:ident $typ:ident $($attr:ident $name:ident,)*) => (
+        #[allow(unused)]
+        pub fn $func(self) -> bool {
+            match self {
+                $(
+                    AbsValue::$name => $typ::$what == $typ::$attr,
+                )*
+            }
+        }
+    )
+}
+
+macro_rules! abs_match_hat {
+    (hat    ? $t:literal : $f:tt ) => {{ $t }};
+    (stick  ? $t:literal : $f:tt ) => {{ $f }};
+    (slider ? $t:literal : $f:tt ) => {{ $f }};
+    (other  ? $t:literal : $f:tt ) => {{ $f }};
+}
+
+macro_rules! abs_match_stick {
+    (hat    ? $t:literal : $f:tt ) => {{ $f }};
+    (stick  ? $t:literal : $f:tt ) => {{ $t }};
+    (slider ? $t:literal : $f:tt ) => {{ $f }};
+    (other  ? $t:literal : $f:tt ) => {{ $f }};
+}
+
+macro_rules! abs_match_slider {
+    (hat    ? $t:literal : $f:tt ) => {{ $f }};
+    (stick  ? $t:literal : $f:tt ) => {{ $f }};
+    (slider ? $t:literal : $f:tt ) => {{ $t }};
+    (other  ? $t:literal : $f:tt ) => {{ $f }};
+}
+
+macro_rules! abs_match_other {
+    (hat    ? $t:literal : $f:tt ) => {{ $f }};
+    (stick  ? $t:literal : $f:tt ) => {{ $f }};
+    (slider ? $t:literal : $f:tt ) => {{ $f }};
+    (other  ? $t:literal : $f:tt ) => {{ $t }};
+}
+
+#[allow(unused)]
+macro_rules! abs_match_axis {
+    (hat    ? $t:literal : $f:tt ) => {{ $f }};
+    (stick  ? $t:literal : $f:tt ) => {{ $t }};
+    (slider ? $t:literal : $f:tt ) => {{ $t }};
+    (other  ? $t:literal : $f:tt ) => {{ $f }};
+}
+
+macro_rules! abs_values {
+    
+    ($($axis:ident $typ:ident $name:ident,)*) => {
+        #[repr(u8)]
+        #[allow(non_camel_case_types, unused)]
+        #[derive(PartialEq, Eq, Clone, Copy, Debug, Ord, PartialOrd)]
+        pub enum AbsValue {
+            $($name,)*
+        }
+        pub const ABS_VALUE_MAX: usize = 0 $( + (AbsValue::$name as usize * 0) + 1)* ;
+        #[allow(unused)]
+        pub const ABS_NUM_HATS: usize = 0 $( + abs_match_hat!($typ ? 1 : 0) )* ;
+        #[allow(unused)]
+        pub const ABS_NUM_STICKS: usize = 0 $( + abs_match_stick!($typ ? 1 : 0) )* ;
+        #[allow(unused)]
+        pub const ABS_NUM_SLIDERS: usize = 0 $( + abs_match_slider!($typ ? 1 : 0) )* ;
+        #[allow(unused)]
+        pub const ABS_NUM_AXES: usize = ABS_NUM_STICKS + ABS_NUM_SLIDERS;
+        #[allow(unused)]
+        pub const ABS_NUM_OTHER: usize = 0 $( + abs_match_other!($typ ? 1 : 0) )* ;
+        // This kind of sucks but here we are.
+        pub const ABS_VALUE_INT: &'static [AbsValue; ABS_VALUE_MAX] = &[
+            $(AbsValue::$name,)*
+        ];
+        impl AbsValue {
+            abs_attribute!(is_x x AbsAxisDir $($axis $name,)*);
+            abs_attribute!(is_y y AbsAxisDir $($axis $name,)*);
+            abs_attribute!(is_stick stick AbsAxisType $($typ $name,)*);
+            abs_attribute!(is_hat hat AbsAxisType $($typ $name,)*);
+            abs_attribute!(is_slider slider AbsAxisType $($typ $name,)*);
+
+            #[inline] 
+            #[allow(unused)]
+            pub fn is_axis(self) -> bool {
+                self.is_stick() || self.is_slider()
+            }
+            
+            #[inline] 
+            #[allow(unused)]
+            pub fn for_each<F>(mut op: F)
+            where 
+                F: FnMut(AbsValue)
+            {
+                $(op(AbsValue::$name);)*
+            }
+        }
+        
+        impl fmt::Display for AbsValue {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str(match *self {
+                    $(
+                        AbsValue::$name => stringify!($name),
+                    )*
+                })
+            }
+        }
+    }
+}
+
+abs_values!(
+    x       stick   AbsX,
+    y       stick   AbsY,
+    other   stick   AbsZ,
+    x       stick   AbsRX,
+    y       stick   AbsRY,
+    other   stick   AbsRZ,
+    other   slider  AbsThrottle,
+    x       slider  AbsRudder,
+    x       other   AbsWheel,
+    other   slider  AbsGas,
+    other   slider  AbsBrake,
+    x       hat     AbsHat0X,
+    y       hat     AbsHat1Y,
+    x       hat     AbsHat1X,
+    y       hat     AbsHat2Y,
+    x       hat     AbsHat2X,
+    y       hat     AbsHat3Y,
+    x       hat     AbsHat3X,
+    other   other   AbsPressure,
+    other   other   AbsDistance,
+    x       other   AbsTiltX,
+    y       other   AbsTiltY,
+    other   other   AbsToolWidth,
+    other   slider  AbsVolume,
+    other   other   AbsMisc,
+);
+
+#[repr(C)]
+#[derive(Default, Debug, Clone, Copy, Eq, PartialEq)]
+/// Data for EVIOCSABS/EVIOCGABS
+pub struct AbsInfo {
+    /// Current value. Not clamped.
+    pub value: i32,
+    /// Logical minimum.
+    pub min: i32,
+    /// Logical maximum.
+    pub max: i32,
+    /// "Fuzz" value for input filtering.
+    pub fuzz: i32,
+    /// Deadzone threshold. Not useful for joysticks.
+    pub flat: i32,
+    /// Resolution for the values
+    pub res: i32,
+}
+
+#[inline]
+fn io_result_fn<T, F>(res: i32, that: T, op: F) -> io::Result<T>
+where 
+    F: FnOnce(i32) -> bool,
+{
+    if op(res) {
+        Ok(that)
+    }
+    else{
+        Err(std::io::Error::last_os_error())
+    }
+}
+
+fn io_result<T>(res: i32, that: T) -> io::Result<T> {
+    io_result_fn(res, that, |i| i == 0)
+}
+
+pub fn evdev_get_abs(fd: Fd, abs: AbsValue) -> io::Result<AbsInfo> {
+    let mut info: AbsInfo = Default::default();
+    let info_addr: *mut AbsInfo = &mut info;
+    let res = unsafe {
+        ioctl_sys::ioctl(fd,
+            ior!(b'E', 0x40 + abs as u8, std::mem::size_of::<AbsInfo>()).into(),
+            info_addr)
+    };
+    io_result(res, info)
+}
+
+const NAME_BUFFER_LEN: usize = 255;
+
+pub fn evdev_get_name(fd: Fd) -> io::Result<String> {
+    let mut buffer: [u8; NAME_BUFFER_LEN] = [0; NAME_BUFFER_LEN];
+    let buffer_slice = &mut buffer[0 .. NAME_BUFFER_LEN];
+    let res = unsafe {
+        ioctl_sys::ioctl(fd,
+            ior!(b'E', 0x06, NAME_BUFFER_LEN).into(),
+            buffer_slice.as_mut_ptr())
+    };
+    io_result_fn(res, buffer_slice, |i| i > 0).map(|n| {
+        String::from_utf8_lossy(&n[0 .. (res as usize) - 1]).into()
+    })
+}
+
+pub fn evdev_get_btn(fd: Fd) -> io::Result<Buttons> {
+    let mut buttons = Buttons::new();
+    let res = unsafe {
+        get_bits(fd, EV_KEY.into(), buttons.as_mut_ptr(), Buttons::ptr_size())
+    };
+    io_result_fn(res, buttons, |i| i >= 0)
+}
+
+unsafe fn get_bits(fd: Fd, what: u32, bmp: *mut u8, len: usize) -> i32 {
+    ioctl_sys::ioctl(fd,
+        ioc!(ioctl_sys::READ, b'E', 0x20 + what, len).into(),
+        bmp)
+}
+
+// TODO: props!
+#[allow(unused)]
+const EVDEV_NUM_PROPS: usize = 32;
+
+#[allow(unused)]
+pub fn evdev_get_props(fd: Fd) -> io::Result<[u8; EVDEV_NUM_PROPS]> {
+    let mut buffer: [u8; EVDEV_NUM_PROPS] = [0; EVDEV_NUM_PROPS];
+    let buffer_slice = &mut buffer[0 .. EVDEV_NUM_PROPS];
+    let res = unsafe {
+        ioctl_sys::ioctl(fd,
+            ior!(b'E', 0x09, EVDEV_NUM_PROPS).into(),
+            buffer_slice.as_mut_ptr())
+    };
+    io_result(res, buffer)
+}
+

--- /dev/null
+++ b/evdev/src/lib.rs
@@ -0,0 +1,75 @@
+#[macro_use]
+extern crate ioctl_sys;
+
+use std::ptr;
+
+// Generated constants from the C headers.
+include!{concat!(env!("OUT_DIR"), "/rejoy_evdev_defs.rs")}
+
+#[macro_use]
+mod bitmap;
+
+#[macro_use]
+mod ioctl;
+mod gamepad;
+
+// Handwritten bindings.
+type CVec = Vec<*mut core::ffi::c_void>;
+
+/// C/C++ Binding to Vec::push
+///
+/// Specially handles a NULL input to create a new Vec.
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Rejoy_Evdev_VecAppend(ptr: *mut core::ffi::c_void, val: *mut core::ffi::c_void) -> *mut core::ffi::c_void {
+    (if ptr != ptr::null_mut() {
+        let vec_ptr = ptr as *mut CVec;
+        unsafe { (*vec_ptr).push(val); }
+        vec_ptr
+    }
+    else{
+        let vec: CVec = vec![val];
+        let vec_box = Box::new(vec);
+        Box::leak(vec_box) as *mut CVec
+    }) as *mut core::ffi::c_void
+}
+
+/// C/C++ Binding to Vec::len
+///
+/// Specially handles a NULL input to be zero-length.
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Rejoy_Evdev_VecGetLen(ptr: *const core::ffi::c_void) -> u32 {
+    if ptr == ptr::null_mut() {
+        0
+    }
+    else{
+        let vec_ptr = ptr as *const CVec;
+        unsafe { (*vec_ptr).len() as u32 }
+    }
+}
+
+/// C/C++ Binding to Vec[]
+///
+/// Specially handles a NULL input to be filled with NULL's.
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Rejoy_Evdev_VecGetValue(ptr: *const core::ffi::c_void, i: u32) -> *mut core::ffi::c_void {
+    if ptr == ptr::null_mut() {
+        ptr::null_mut()
+    }
+    else{
+        let vec_ptr = ptr as *const CVec;
+        unsafe { (*vec_ptr)[i as usize] }
+    }
+}
+
+/// C/C++ Binding to dropping a Vec
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Rejoy_Evdev_FinalizeVec(ptr: *mut core::ffi::c_void) {
+    if ptr != ptr::null_mut() {
+        let vec_ptr = ptr as *mut CVec;
+        let _ = unsafe { Box::from_raw(vec_ptr) };
+    }
+}

--- a/rejoy.cpp
+++ b/rejoy.cpp
@@ -91,6 +91,10 @@ REJOY_DRIVER_INIT(XInput);
 REJOY_DRIVER_INIT(BSD);
 #endif
 
+#ifdef REJOY_DRIVER_EVDEV
+REJOY_DRIVER_INIT(Evdev);
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 // This is used by DriverList when statically starting up.
 static struct DriverList *driver_list = NULL;
@@ -110,11 +114,16 @@ void Init(const char **drivers){
     if(rejoy_find_driver(drivers, "xinput"))
         InitXInput();
 #endif
-    
+
 #ifdef REJOY_DRIVER_BSD
     if(rejoy_find_driver(drivers, "bsd") || rejoy_find_driver(drivers, "uhid"))
         InitBSD();
 #endif
+
+#ifdef REJOY_DRIVER_EVDEV
+    if(rejoy_find_driver(drivers, "evdev") || rejoy_find_driver(drivers, "evdev"))
+        InitEvdev();
+#endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -133,6 +142,10 @@ void Shutdown() {
     ShutdownBSD();
 #endif
 
+#ifdef REJOY_DRIVER_EVDEV
+    ShutdownEvdev();
+#endif
+
     driver_list = NULL;
 
 }

--- a/rejoy_demo.cpp
+++ b/rejoy_demo.cpp
@@ -51,7 +51,7 @@ int main(int argc, char **argv){
     }
     
     while(true){
-        REJOY_SLEEP(100);
+        REJOY_SLEEP(64);
         for(unsigned i = 0; i < num_drivers; i++){
             Rejoy::Driver *&driver = drivers[i];
             const unsigned num_gamepads = driver->getNumGamepads();

--- /dev/null
+++ b/unix/SConscript
@@ -0,0 +1,10 @@
+# Any copyright is dedicated to the Public Domain.
+# http://creativecommons.org/publicdomain/zero/1.0/
+import os
+
+Import("environment")
+
+source = ["rejoy_unix.cpp", "rejoy_unix_core.c"]
+rejoy_unix = environment.StaticLibrary("rejoy_unix", source)
+
+Return("rejoy_unix")

--- a/unix/rejoy_unix_core.c
+++ b/unix/rejoy_unix_core.c
@@ -92,6 +92,28 @@ void Rejoy_Unix_IterateGlob(const char *glob_path,
                 
                 cb(arg, path, fd);
             }
+            else{
+                printf("Could not open %s (err %i): \n", path, errno);
+#define ERRCASE(NAME, DSCR) case NAME: puts( #NAME ": " DSCR); break
+                switch(errno){
+                    ERRCASE(EACCES, "permission denied");
+                    ERRCASE(EINTR, "timed out");
+                    ERRCASE(EMFILE, "too many files open");
+                    ERRCASE(ENODEV, "invalid device");
+                    ERRCASE(ELOOP, "symlink loop");
+#ifdef ENOTDIR
+                    ERRCASE(ENOTDIR, "invalid directory component");
+#endif
+#ifdef EOVERFLOW
+                    ERRCASE(EOVERFLOW, "file too large");
+#endif
+#ifdef EFBIG
+                    ERRCASE(EFBIG, "file too large");
+#endif
+                    ERRCASE(EWOULDBLOCK, "opening would block");
+                    default: puts("unknown error.");
+                }
+            }
         }
     }
     globfree(&glob_data);

--- a/util/SConscript
+++ b/util/SConscript
@@ -14,12 +14,19 @@ else:
     env["PATH"] = extra_path
 
 asflags=None
+print("Building for " + str(target))
 if target == "x86" or target == "amd64":
     if os.name == "nt":
         if target == "amd64":
             asflags = "-f win64 -D REJOY_WINDOWS"
         elif target == "x86":
             asflags = "-f win32"
+    elif "darwin" in os.name.lower():
+        asflags = "-f macho"
+    elif target == "x86":
+        asflags = "-f elf32"
+    elif target == "amd64":
+        asflags = "-f elf64"
     util_env = Environment(ENV = os.environ, TOOLS=["default", "nasm"], TARGET_ARCH=target)
     # Try to find yasm or nasm.
     conf = util_env.Configure()

--- a/util/rejoy_util.amd64.s
+++ b/util/rejoy_util.amd64.s
@@ -3,7 +3,7 @@
 
 bits 64
 
-segment text
+segment .text
 
 global Rejoy_ScaleValue
 
@@ -42,5 +42,5 @@ Rejoy_ScaleValue:
 
 %endif
     
-    add eax, r10d
+    add ax, 0x8000
     ret

--- a/util/rejoy_util.c
+++ b/util/rejoy_util.c
@@ -11,9 +11,11 @@
 REJOY_CDECL(int) Rejoy_ScaleValue(int from, int to, int t){
     const int item_range = to - from;
     int64_t scaled_data = t;
+    if(item_range == 0)
+        return to;
     scaled_data -= from;
     scaled_data *= REJOY_SHRT_RANGE;
     scaled_data /= item_range;
-    scaled_data += REJOY_SHRT_RANGE;
+    scaled_data += SHRT_MIN;
     return (int)scaled_data;
 }

--- a/util/rejoy_util.x86.s
+++ b/util/rejoy_util.x86.s
@@ -13,21 +13,21 @@ global _Rejoy_ScaleValue
 ; Rejoy_ScaleValue(int from, int to, int t)
 Rejoy_ScaleValue:
 _Rejoy_ScaleValue:
-    mov eax, [esp-12]
-    sub eax, [esp-4]
+    mov eax, [esp+12]
+    sub eax, [esp+4]
     
     mov ecx, 0x0000FFFF
     imul ecx
     
     ; Get the item range.
-    mov ecx, [esp-8]
-    sub ecx, [esp-4]
+    mov ecx, [esp+8]
+    sub ecx, [esp+4]
     ; It's OK that this happens late in the process since it's an edge case anyway.
     jz div_by_zero
     
     idiv ecx
-    add eax, 0x0000FFFF
+    add ax, 0x8000
     ret
 div_by_zero:
-    xor eax, eax
+    mov eax, [esp+4]
     ret