lovr.headset.getAxis;

Takes a path and returns 1-3 float values representing the components
of the axis at the path.  The "touchx" and "touchy" axes are now just
"touchpad".

src/api/headset.c

@@ -78,7 +78,10 @@ const char* Subpaths[] = {
   [PATH_HEAD] = "head",
   [PATH_HANDS] = "hands",
   [PATH_LEFT] = "left",
-  [PATH_RIGHT] = "right"
+  [PATH_RIGHT] = "right",
+  [PATH_TRIGGER] = "trigger",
+  [PATH_GRIP] = "grip",
+  [PATH_TOUCHPAD] = "touchpad"
 };
 
 typedef struct {
@@ -336,6 +339,22 @@ int l_lovrHeadsetGetAngularVelocity(lua_State* L) {
   return 0;
 }
 
+int l_lovrHeadsetGetAxis(lua_State* L) {
+  Path path = luax_optpath(L, 1, "head");
+  float x, y, z;
+  int count;
+  FOREACH_TRACKING_DRIVER(driver) {
+    if ((count = driver->getAxis(path, &x, &y, &z)) > 0) {
+      lua_pushnumber(L, x);
+      lua_pushnumber(L, y);
+      lua_pushnumber(L, z);
+      lua_pop(L, 3 - count);
+      return count;
+    }
+  }
+  return 0;
+}
+
 static int l_lovrHeadsetGetControllers(lua_State* L) {
   uint8_t count;
   Controller** controllers = lovrHeadsetDriver->getControllers(&count);
@@ -411,6 +430,7 @@ static const luaL_Reg lovrHeadset[] = {
   { "getDirection", l_lovrHeadsetGetDirection },
   { "getVelocity", l_lovrHeadsetGetVelocity },
   { "getAngularVelocity", l_lovrHeadsetGetAngularVelocity },
+  { "getAxis", l_lovrHeadsetGetAxis },
   { "getControllers", l_lovrHeadsetGetControllers },
   { "getControllerCount", l_lovrHeadsetGetControllerCount },
   { "renderTo", l_lovrHeadsetRenderTo },

src/api/headset.h

@@ -6,5 +6,6 @@ int l_lovrHeadsetGetPosition(lua_State* L);
 int l_lovrHeadsetGetOrientation(lua_State* L);
 int l_lovrHeadsetGetVelocity(lua_State* L);
 int l_lovrHeadsetGetAngularVelocity(lua_State* L);
+int l_lovrHeadsetGetAxis(lua_State* L);
 Path luax_optpath(lua_State* L, int index, const char* fallback);
 void luax_pushpath(lua_State* L, Path path);

src/api/types/controller.c

@@ -65,9 +65,9 @@ static int l_lovrControllerGetAngularVelocity(lua_State* L) {
 
 static int l_lovrControllerGetAxis(lua_State* L) {
   Controller* controller = luax_checktype(L, 1, Controller);
-  ControllerAxis axis = luaL_checkoption(L, 2, NULL, ControllerAxes);
-  lua_pushnumber(L, lovrHeadsetDriver->controllerGetAxis(controller, axis));
-  return 1;
+  luax_pushpath(L, controller->path);
+  lua_replace(L, 1);
+  return l_lovrHeadsetGetAxis(L);
 }
 
 static int l_lovrControllerIsDown(lua_State* L) {

src/headset/desktop.c

@@ -150,6 +150,10 @@ static bool desktopGetAngularVelocity(Path path, float* vx, float* vy, float* vz
   return false;
 }
 
+static int desktopGetAxis(Path path, float* x, float* y, float* z) {
+  return 0;
+}
+
 static Controller** desktopGetControllers(uint8_t* count) {
   *count = state.controllers.length;
   return state.controllers.data;
@@ -163,10 +167,6 @@ static ControllerHand desktopControllerGetHand(Controller* controller) {
   return HAND_UNKNOWN;
 }
 
-static float desktopControllerGetAxis(Controller* controller, ControllerAxis axis) {
-  return 0.f;
-}
-
 static bool desktopControllerIsDown(Controller* controller, ControllerButton button) {
   return lovrPlatformIsMouseDown(MOUSE_RIGHT);
 }
@@ -274,10 +274,10 @@ HeadsetInterface lovrHeadsetDesktopDriver = {
   .getPose = desktopGetPose,
   .getVelocity = desktopGetVelocity,
   .getAngularVelocity = desktopGetAngularVelocity,
+  .getAxis = desktopGetAxis,
   .getControllers = desktopGetControllers,
   .controllerIsConnected = desktopControllerIsConnected,
   .controllerGetHand = desktopControllerGetHand,
-  .controllerGetAxis = desktopControllerGetAxis,
   .controllerIsDown = desktopControllerIsDown,
   .controllerIsTouched = desktopControllerIsTouched,
   .controllerVibrate = desktopControllerVibrate,

src/headset/headset.h

@@ -41,7 +41,10 @@ typedef enum {
   PATH_HEAD,
   PATH_HANDS,
   PATH_LEFT,
-  PATH_RIGHT
+  PATH_RIGHT,
+  PATH_TRIGGER,
+  PATH_GRIP,
+  PATH_TOUCHPAD
 } Subpath;
 
 typedef union {
@@ -109,10 +112,10 @@ typedef struct HeadsetInterface {
   bool (*getPose)(Path path, float* x, float* y, float* z, float* angle, float* ax, float* ay, float* az);
   bool (*getVelocity)(Path path, float* vx, float* vy, float* vz);
   bool (*getAngularVelocity)(Path path, float* vx, float* vy, float* vz);
+  int (*getAxis)(Path path, float* x, float* y, float* z);
   Controller** (*getControllers)(uint8_t* count);
   bool (*controllerIsConnected)(Controller* controller);
   ControllerHand (*controllerGetHand)(Controller* controller);
-  float (*controllerGetAxis)(Controller* controller, ControllerAxis axis);
   bool (*controllerIsDown)(Controller* controller, ControllerButton button);
   bool (*controllerIsTouched)(Controller* controller, ControllerButton button);
   void (*controllerVibrate)(Controller* controller, float duration, float power);

src/headset/openvr.c

@@ -313,6 +313,58 @@ static bool openvrGetAngularVelocity(Path path, float* vx, float* vy, float* vz)
   }
 }
 
+static int openvrGetAxis(Path path, float* x, float* y, float* z) {
+  if (path.pieces[3] != PATH_NONE) {
+    return 0;
+  }
+
+  TrackedDeviceIndex_t deviceIndex = getDeviceIndexForPath(path);
+  if (deviceIndex == INVALID_INDEX) {
+    return 0;
+  }
+
+  VRControllerState_t input;
+  if (!state.system->GetControllerState(deviceIndex, &input, sizeof(input))) {
+    return 0;
+  }
+
+  switch (state.type) {
+    case HEADSET_RIFT:
+      switch (path.pieces[2]) {
+        case PATH_TRIGGER:
+          *x = input.rAxis[1].x;
+          return 1;
+
+        case PATH_GRIP:
+          *x = input.rAxis[2].x;
+          return 1;
+
+        case PATH_TOUCHPAD:
+          *x = input.rAxis[0].x;
+          *y = input.rAxis[0].y;
+          return 2;
+
+        default: return 0;
+      }
+
+    default:
+      switch (path.pieces[2]) {
+        case PATH_TRIGGER:
+          *x = input.rAxis[1].x;
+          return 1;
+
+        case PATH_TOUCHPAD:
+          *x = input.rAxis[0].x;
+          *y = input.rAxis[0].y;
+          return 2;
+
+        default: return 0;
+      }
+  }
+
+  return 0;
+}
+
 static Controller** openvrGetControllers(uint8_t* count) {
   *count = state.controllers.length;
   return state.controllers.data;
@@ -330,34 +382,6 @@ static ControllerHand openvrControllerGetHand(Controller* controller) {
   }
 }
 
-static float openvrControllerGetAxis(Controller* controller, ControllerAxis axis) {
-  if (!controller) return 0;
-
-  VRControllerState_t input;
-  state.system->GetControllerState(controller->id, &input, sizeof(input));
-
-  switch (state.type) {
-    case HEADSET_RIFT:
-      switch (axis) {
-        case CONTROLLER_AXIS_TRIGGER: return input.rAxis[1].x;
-        case CONTROLLER_AXIS_GRIP: return input.rAxis[2].x;
-        case CONTROLLER_AXIS_TOUCHPAD_X: return input.rAxis[0].x;
-        case CONTROLLER_AXIS_TOUCHPAD_Y: return input.rAxis[0].y;
-        default: return 0;
-      }
-
-    default:
-      switch (axis) {
-        case CONTROLLER_AXIS_TRIGGER: return input.rAxis[1].x;
-        case CONTROLLER_AXIS_TOUCHPAD_X: return input.rAxis[0].x;
-        case CONTROLLER_AXIS_TOUCHPAD_Y: return input.rAxis[0].y;
-        default: return 0;
-      }
-  }
-
-  return 0;
-}
-
 static bool openvrControllerIsDown(Controller* controller, ControllerButton button) {
   VRControllerState_t input;
   state.system->GetControllerState(controller->id, &input, sizeof(input));
@@ -614,10 +638,10 @@ HeadsetInterface lovrHeadsetOpenVRDriver = {
   .getPose = openvrGetPose,
   .getVelocity = openvrGetVelocity,
   .getAngularVelocity = openvrGetAngularVelocity,
+  .getAxis = openvrGetAxis,
   .getControllers = openvrGetControllers,
   .controllerIsConnected = openvrControllerIsConnected,
   .controllerGetHand = openvrControllerGetHand,
-  .controllerGetAxis = openvrControllerGetAxis,
   .controllerIsDown = openvrControllerIsDown,
   .controllerIsTouched = openvrControllerIsTouched,
   .controllerVibrate = openvrControllerVibrate,