Implement glfw joystick API (#5175)

* Implement glfw joystick API

Joystick connected/disconnected callbacks are called in
refreshJoysticks(). The gamepadconnected/disconnected events are only
used as a hint to refresh the joysticks, whose getGamepads() state is
compared to the previous state to determine the new state.

Author: satoshinm

src/library_glfw.js

@@ -13,7 +13,6 @@
  * What it does not but should probably do:
  * - Transmit events when glfwPollEvents, glfwWaitEvents or glfwSwapBuffers is
  *    called. Events callbacks are called as soon as event are received.
- * - Joystick support.
  * - Input modes.
  * - Gamma ramps.
  * - Video modes.
@@ -81,6 +80,7 @@ var LibraryGLFW = {
       return GLFW.windows[id - 1];
     },
 
+    joystickFunc: null, // GLFWjoystickfun
     errorFunc: null, // GLFWerrorfun
     monitorFunc: null, // GLFWmonitorfun
     active: null, // active window
@@ -382,6 +382,14 @@ var LibraryGLFW = {
 #endif
     },
 
+    onGamepadConnected: function(event) {
+      GLFW.refreshJoysticks();
+    },
+
+    onGamepadDisconnected: function(event) {
+      GLFW.refreshJoysticks();
+    },
+
     onKeydown: function(event) {
       GLFW.onKeyChanged(event.keyCode, 1); // GLFW_PRESS or GLFW_REPEAT
 
@@ -641,6 +649,68 @@ var LibraryGLFW = {
       }
     },
 
+    setJoystickCallback: function(cbfun) {
+      GLFW.joystickFunc = cbfun;
+      GLFW.refreshJoysticks();
+    },
+
+    joys: {}, // glfw joystick data
+    lastGamepadState: null,
+    lastGamepadStateFrame: null, // The integer value of Browser.mainLoop.currentFrameNumber of when the last gamepad state was produced.
+
+    refreshJoysticks: function() {
+      // Produce a new Gamepad API sample if we are ticking a new game frame, or if not using emscripten_set_main_loop() at all to drive animation.
+      if (Browser.mainLoop.currentFrameNumber !== GLFW.lastGamepadStateFrame || !Browser.mainLoop.currentFrameNumber) {
+        GLFW.lastGamepadState = navigator.getGamepads ? navigator.getGamepads() : (navigator.webkitGetGamepads ? navigator.webkitGetGamepads : null);
+        GLFW.lastGamepadStateFrame = Browser.mainLoop.currentFrameNumber;
+
+        for (var joy = 0; joy < GLFW.lastGamepadState.length; ++joy) {
+          var gamepad = GLFW.lastGamepadState[joy];
+
+          if (gamepad) {
+            if (!GLFW.joys[joy]) {
+              console.log('glfw joystick connected:',joy);
+              GLFW.joys[joy] = {
+                id: allocate(intArrayFromString(gamepad.id), 'i8', ALLOC_NORMAL),
+                buttonsCount: gamepad.buttons.length,
+                axesCount: gamepad.axes.length,
+                buttons: allocate(new Array(gamepad.buttons.length), 'i8', ALLOC_NORMAL),
+                axes: allocate(new Array(gamepad.axes.length*4), 'float', ALLOC_NORMAL)
+              };
+
+              if (GLFW.joystickFunc) {
+                Module['dynCall_vii'](GLFW.joystickFunc, joy, 0x00040001); // GLFW_CONNECTED
+              }
+            }
+
+            var data = GLFW.joys[joy];
+
+            for (var i = 0; i < gamepad.buttons.length;  ++i) {
+              setValue(data.buttons + i, gamepad.buttons[i].pressed, 'i8');
+            }
+
+            for (var i = 0; i < gamepad.axes.length; ++i) {
+              setValue(data.axes + i*4, gamepad.axes[i], 'float');
+            }
+          } else {
+            if (GLFW.joys[joy]) {
+              console.log('glfw joystick disconnected',joy);
+
+              if (GLFW.joystickFunc) {
+                Module['dynCall_vii'](GLFW.joystickFunc, joy, 0x00040002); // GLFW_DISCONNECTED
+              }
+
+              _free(GLFW.joys[joy].id);
+              _free(GLFW.joys[joy].buttons);
+              _free(GLFW.joys[joy].axes);
+
+              delete GLFW.joys[joy];
+            }
+          }
+        }
+      }
+    },
+
     setKeyCallback: function(winid, cbfun) {
       var win = GLFW.WindowFromId(winid);
       if (!win) return;
@@ -954,6 +1024,8 @@ var LibraryGLFW = {
     GLFW.windows = new Array()
     GLFW.active = null;
 
+    window.addEventListener("gamepadconnected", GLFW.onGamepadConnected, true);
+    window.addEventListener("gamepaddisconnected", GLFW.onGamepadDisconnected, true);
     window.addEventListener("keydown", GLFW.onKeydown, true);
     window.addEventListener("keypress", GLFW.onKeyPress, true);
     window.addEventListener("keyup", GLFW.onKeyup, true);
@@ -973,6 +1045,8 @@ var LibraryGLFW = {
   },
 
   glfwTerminate: function() {
+    window.removeEventListener("gamepadconnected", GLFW.onGamepadConnected, true);
+    window.removeEventListener("gamepaddisconnected", GLFW.onGamepadDisconnected, true);
     window.removeEventListener("keydown", GLFW.onKeydown, true);
     window.removeEventListener("keypress", GLFW.onKeyPress, true);
     window.removeEventListener("keyup", GLFW.onKeyup, true);
@@ -1354,15 +1428,49 @@ var LibraryGLFW = {
 
   glfwCreateWindowSurface: function(instance, winid, allocator, surface) { throw "glfwCreateWindowSurface is not implemented."; },
 
-  glfwSetJoystickCallback: function(cbfun) { throw "glfwSetJoystickCallback is not implemented."; },
+  glfwJoystickPresent: function(joy) {
+    GLFW.refreshJoysticks();
 
-  glfwJoystickPresent: function(joy) { throw "glfwJoystickPresent is not implemented."; },
+    return GLFW.joys[joy] !== undefined;
+  },
 
-  glfwGetJoystickAxes: function(joy, count) { throw "glfwGetJoystickAxes is not implemented."; },
+  glfwGetJoystickAxes: function(joy, count) {
+    GLFW.refreshJoysticks();
+
+    var state = GLFW.joys[joy];
+    if (!state || !state.axes) {
+      setValue(count, 0, 'i32');
+      return;
+    }
+
+    setValue(count, state.axesCount, 'i32');
+    return state.axes;
+  },
 
-  glfwGetJoystickButtons: function(joy, count) { throw "glfwGetJoystickButtons is not implemented."; },
+  glfwGetJoystickButtons: function(joy, count) {
+    GLFW.refreshJoysticks();
 
-  glfwGetJoystickName: function(joy) { throw "glfwGetJoystickName is not implemented."; },
+    var state = GLFW.joys[joy];
+    if (!state || !state.buttons) {
+      setValue(count, 0, 'i32');
+      return;
+    }
+
+    setValue(count, state.buttonsCount, 'i32');
+    return state.buttons;
+  },
+
+  glfwGetJoystickName: function(joy) {
+    if (GLFW.joys[joy]) {
+      return GLFW.joys[joy].id;
+    } else {
+      return 0;
+    }
+  },
+
+  glfwSetJoystickCallback: function(cbfun) {
+    GLFW.setJoystickCallback(cbfun);
+  },
 
   glfwSetClipboardString: function(win, string) {},
 

tests/glfw_joystick.c

@@ -0,0 +1,105 @@
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#endif
+#define GLFW_INCLUDE_ES2
+#include <GLFW/glfw3.h>
+
+int result = 1;
+
+GLFWwindow* g_window;
+
+void render();
+void error_callback(int error, const char* description);
+
+void render() {
+  glClearColor(0.7f, 0.7f, 0.7f, 1.0f);
+  glClear(GL_COLOR_BUFFER_BIT);
+
+  for (int j = GLFW_JOYSTICK_1; j < GLFW_JOYSTICK_16; ++j) {
+    int joy = GLFW_JOYSTICK_1 + j;
+    if (!glfwJoystickPresent(joy)) continue;
+
+    static struct {
+      int axes_count;
+      float axes[16];
+      int button_count;
+      unsigned char buttons[16];
+    } last_gamepad_state[16] = {0};
+
+    const char *name = glfwGetJoystickName(joy);
+
+    int axes_count = 0;
+    const float *axes = glfwGetJoystickAxes(joy, &axes_count);
+
+    int button_count = 0;
+    const unsigned char *buttons = glfwGetJoystickButtons(joy, &button_count);
+
+    last_gamepad_state[joy].axes_count = axes_count;
+    for (int i = 0; i < axes_count; ++i) {
+      if (last_gamepad_state[joy].axes[i] != axes[i]) {
+        printf("(%d %s) axis %d = %f\n", joy, name, i, axes[i]);
+      }
+
+      last_gamepad_state[joy].axes[i] = axes[i];
+    }
+
+    last_gamepad_state[joy].button_count =  button_count;
+    for (int i = 0; i < button_count; ++i) {
+      if (last_gamepad_state[joy].buttons[i] != buttons[i]) {
+        printf("(%d %s) button %d = %d\n", joy, name, i, buttons[i]);
+      }
+
+      last_gamepad_state[joy].buttons[i] = buttons[i];
+    }
+  }
+}
+
+void joystick_callback(int joy, int event)
+{
+  if (event == GLFW_CONNECTED) {
+    printf("Joystick %d was connected: %s\n", joy, glfwGetJoystickName(joy));
+  } else if (event == GLFW_DISCONNECTED) {
+    printf("Joystick %d was disconnected\n", joy);
+  }
+}
+
+int main() {
+  if (!glfwInit())
+  {
+    result = 0;
+    printf("Could not create window. Test failed.\n");
+#ifdef REPORT_RESULT
+    REPORT_RESULT();
+#endif
+    return -1;
+  }
+  glfwWindowHint(GLFW_RESIZABLE , 1);
+  g_window = glfwCreateWindow(600, 450, "GLFW joystick test", NULL, NULL);
+  if (!g_window)
+  {
+    result = 0;
+    printf("Could not create window. Test failed.\n");
+#ifdef REPORT_RESULT
+    REPORT_RESULT();
+#endif
+    glfwTerminate();
+    return -1;
+  }
+  glfwMakeContextCurrent(g_window);
+  glfwSetJoystickCallback(joystick_callback);
+
+#ifdef __EMSCRIPTEN__
+    emscripten_set_main_loop(render, 0, 1);
+#else
+  while (!glfwWindowShouldClose(window)) {
+    glfwPollEvents();
+  }
+#endif
+
+  glfwTerminate();
+
+  return 0;
+}

tests/test_browser.py

@@ -1097,6 +1097,53 @@ def test_sdl_joystick_2(self):
     Popen([PYTHON, EMCC, os.path.join(self.get_dir(), 'sdl_joystick.c'), '-O2', '--minify', '0', '-o', 'page.html', '--pre-js', 'pre.js', '-lSDL', '-lGL']).communicate()
     self.run_browser('page.html', '', '/report_result?2')
 
+  def test_glfw_joystick(self):
+    # Generates events corresponding to the Editor's Draft of the HTML5 Gamepad API.
+    # https://dvcs.w3.org/hg/gamepad/raw-file/default/gamepad.html#idl-def-Gamepad
+    open(os.path.join(self.get_dir(), 'pre.js'), 'w').write('''
+      var gamepads = [];
+      // Spoof this function.
+      navigator['getGamepads'] = function() {
+        return gamepads;
+      };
+      window['addNewGamepad'] = function(id, numAxes, numButtons) {
+        var index = gamepads.length;
+        var gamepad = {
+          axes: new Array(numAxes),
+          buttons: new Array(numButtons),
+          id: id,
+          index: index
+        };
+        gamepads.push(gamepad)
+        var i;
+        for (i = 0; i < numAxes; i++) gamepads[index].axes[i] = 0;
+        // Buttons are objects
+        for (i = 0; i < numButtons; i++) gamepads[index].buttons[i] = { pressed: false, value: 0 };
+
+        // Dispatch event (required for glfw joystick; note not used in SDL test)
+        var event = new Event('gamepadconnected');
+        event.gamepad = gamepad;
+        window.dispatchEvent(event);
+      };
+      // FF mutates the original objects.
+      window['simulateGamepadButtonDown'] = function (index, button) {
+        gamepads[index].buttons[button].pressed = true;
+        gamepads[index].buttons[button].value = 1;
+      };
+      window['simulateGamepadButtonUp'] = function (index, button) {
+        gamepads[index].buttons[button].pressed = false;
+        gamepads[index].buttons[button].value = 0;
+      };
+      window['simulateAxisMotion'] = function (index, axis, value) {
+        gamepads[index].axes[axis] = value;
+      };
+    ''')
+    open(os.path.join(self.get_dir(), 'test_glfw_joystick.c'), 'w').write(self.with_report_result(open(path_from_root('tests', 'test_glfw_joystick.c')).read()))
+
+    Popen([PYTHON, EMCC, os.path.join(self.get_dir(), 'test_glfw_joystick.c'), '-O2', '--minify', '0', '-o', 'page.html', '--pre-js', 'pre.js', '-lGL', '-lglfw3', '-s', 'USE_GLFW=3']).communicate()
+    self.run_browser('page.html', '', '/report_result?2')
+
+
   def test_webgl_context_attributes(self):
     # Javascript code to check the attributes support we want to test in the WebGL implementation 
     # (request the attribute, create a context and check its value afterwards in the context attributes).