More headset functions;

src/headset/headset.c

@@ -12,18 +12,18 @@ extern __declspec(dllimport) intptr_t VR_InitInternal(EVRInitError *peError, EVR
 extern __declspec(dllimport) bool VR_IsInterfaceVersionValid(const char *pchInterfaceVersion);
 extern __declspec(dllimport) intptr_t VR_GetGenericInterface(const char *pchInterfaceVersion, EVRInitError *peError);
 
-#define DEVICE_COUNT 16
-
 typedef struct {
   struct VR_IVRSystem_FnTable* vrSystem;
   struct VR_IVRCompositor_FnTable* vrCompositor;
 
-  GLuint framebuffer;
-  GLuint depthbuffer;
-  GLuint texture;
+  unsigned int deviceIndex;
 
   uint32_t renderWidth;
   uint32_t renderHeight;
+
+  GLuint framebuffer;
+  GLuint depthbuffer;
+  GLuint texture;
 } HeadsetState;
 
 static HeadsetState headsetState;
@@ -49,7 +49,7 @@ void lovrHeadsetInit() {
   }
 
   char fnTableName[128];
-  
+
   sprintf(fnTableName, "FnTable:%s", IVRSystem_Version);
   headsetState.vrSystem = (struct VR_IVRSystem_FnTable*) VR_GetGenericInterface(fnTableName, &vrError);
   if (vrError != EVRInitError_VRInitError_None || headsetState.vrSystem == NULL) {
@@ -64,6 +64,8 @@ void lovrHeadsetInit() {
     return;
   }
 
+  headsetState.deviceIndex = k_unTrackedDeviceIndex_Hmd;
+
   headsetState.vrSystem->GetRecommendedRenderTargetSize(&headsetState.renderWidth, &headsetState.renderHeight);
 
   glGenFramebuffers(1, &headsetState.framebuffer);
@@ -89,6 +91,10 @@ void lovrHeadsetInit() {
   }
 
   glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+  char prop[64];
+  headsetState.vrSystem->GetStringTrackedDeviceProperty(headsetState.deviceIndex, ETrackedDeviceProperty_Prop_ModelNumber_String, prop, 64, NULL);
+  printf("%s\n", prop);
 }
 
 int lovrHeadsetGetDisplayWidth() {
@@ -99,6 +105,34 @@ int lovrHeadsetGetDisplayHeight() {
   return headsetState.renderHeight;
 }
 
+int lovrHeadsetIsConnected() {
+  return (int) headsetState.vrSystem->IsTrackedDeviceConnected(headsetState.deviceIndex);
+}
+
+DeviceStatus lovrHeadsetGetStatus() {
+  EDeviceActivityLevel activityLevel = headsetState.vrSystem->GetTrackedDeviceActivityLevel(headsetState.deviceIndex);
+
+  switch (activityLevel) {
+    case EDeviceActivityLevel_k_EDeviceActivityLevel_Unknown:
+      return STATUS_UNKNOWN;
+
+    case EDeviceActivityLevel_k_EDeviceActivityLevel_Idle:
+      return STATUS_IDLE;
+
+    case EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction:
+      return STATUS_USER_INTERACTION;
+
+    case EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction_Timeout:
+      return STATUS_USER_INTERACTION_TIMEOUT;
+
+    case EDeviceActivityLevel_k_EDeviceActivityLevel_Standby:
+      return STATUS_STANDBY;
+
+    default:
+      return STATUS_UNKNOWN;
+  }
+}
+
 void lovrHeadsetRenderTo(headsetRenderCallback callback, void* userdata) {
   TrackedDevicePose_t pose;
   headsetState.vrCompositor->WaitGetPoses(&pose, 1, NULL, 0);

src/headset/headset.h

@@ -1,8 +1,19 @@
 #ifndef LOVR_HEADSET_TYPES
 typedef void (*headsetRenderCallback)(int eyeIndex, void* userdata);
+
+typedef enum {
+  STATUS_IDLE,
+  STATUS_USER_INTERACTION,
+  STATUS_USER_INTERACTION_TIMEOUT,
+  STATUS_STANDBY,
+  STATUS_UNKNOWN,
+  STATUS_MAX_ENUM
+} DeviceStatus;
 #endif
 
 void lovrHeadsetInit();
 int lovrHeadsetGetDisplayWidth();
 int lovrHeadsetGetDisplayHeight();
+int lovrHeadsetIsConnected();
+DeviceStatus lovrHeadsetGetStatus();
 void lovrHeadsetRenderTo(headsetRenderCallback callback, void* userdata);

src/lovr/headset.c

@@ -13,6 +13,8 @@ const luaL_Reg lovrHeadset[] = {
   { "getDisplayWidth", l_lovrHeadsetGetDisplayWidth },
   { "getDisplayHeight", l_lovrHeadsetGetDisplayHeight },
   { "getDisplayDimensions", l_lovrHeadsetGetDisplayDimensions },
+  { "getStatus", l_lovrHeadsetGetStatus },
+  { "isConnected", l_lovrHeadsetIsConnected },
   { "renderTo", l_lovrHeadsetRenderTo },
   { NULL, NULL }
 };
@@ -40,6 +42,37 @@ int l_lovrHeadsetGetDisplayDimensions(lua_State* L) {
   return 2;
 }
 
+int l_lovrHeadsetGetStatus(lua_State* L) {
+  DeviceStatus status = lovrHeadsetGetStatus();
+
+  switch (status) {
+    case STATUS_IDLE:
+      lua_pushstring(L, "idle");
+      break;
+
+    case STATUS_USER_INTERACTION:
+      lua_pushstring(L, "active");
+      break;
+
+    case STATUS_USER_INTERACTION_TIMEOUT:
+      lua_pushstring(L, "timeout");
+
+    case STATUS_STANDBY:
+      lua_pushstring(L, "standby");
+
+    default:
+      lua_pushstring(L, "unknown");
+      break;
+  }
+
+  return 1;
+}
+
+int l_lovrHeadsetIsConnected(lua_State* L) {
+  lua_pushboolean(L, lovrHeadsetIsConnected());
+  return 1;
+}
+
 int l_lovrHeadsetRenderTo(lua_State* L) {
   luaL_checktype(L, 1, LUA_TFUNCTION);
   lovrHeadsetRenderTo(renderHelper, L);

src/lovr/headset.h

@@ -7,4 +7,6 @@ int l_lovrHeadsetInit(lua_State* L);
 int l_lovrHeadsetGetDisplayWidth(lua_State* L);
 int l_lovrHeadsetGetDisplayHeight(lua_State* L);
 int l_lovrHeadsetGetDisplayDimensions(lua_State* L);
+int l_lovrHeadsetGetStatus(lua_State* L);
+int l_lovrHeadsetIsConnected(lua_State* L);
 int l_lovrHeadsetRenderTo(lua_State* L);