lpnf
/
lovr
mirror of https://github.com/bjornbytes/lovr.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Remove Controllers;

This commit is contained in:
bjorn 2019-04-06 13:10:16 -07:00
parent bd609fc338
commit da6fd4d07c
10 changed files with 617 additions and 1080 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/api.h
View File

@ -26,7 +26,6 @@ extern const luaL_Reg lovrCanvas[];
extern const luaL_Reg lovrCapsuleShape[];
extern const luaL_Reg lovrChannel[];
extern const luaL_Reg lovrCollider[];
extern const luaL_Reg lovrController[];
extern const luaL_Reg lovrCurve[];
extern const luaL_Reg lovrCylinderShape[];
extern const luaL_Reg lovrDistanceJoint[];
@ -64,9 +63,6 @@ extern const char* BlendModes[];
extern const char* BlockTypes[];
extern const char* BufferUsages[];
extern const char* CompareModes[];
extern const char* ControllerAxes[];
extern const char* ControllerButtons[];
extern const char* ControllerHands[];
extern const char* DrawModes[];
extern const char* DrawStyles[];
extern const char* EventTypes[];

20
src/api/event.c
View File

@ -7,12 +7,6 @@ const char* EventTypes[] = {
[EVENT_FOCUS] = "focus",
[EVENT_MOUNT] = "mount",
[EVENT_THREAD_ERROR] = "threaderror",
#ifdef LOVR_ENABLE_HEADSET
[EVENT_CONTROLLER_ADDED] = "controlleradded",
[EVENT_CONTROLLER_REMOVED] = "controllerremoved",
[EVENT_CONTROLLER_PRESSED] = "controllerpressed",
[EVENT_CONTROLLER_RELEASED] = "controllerreleased",
#endif
};
static _Thread_local int pollRef;
@ -100,20 +94,6 @@ static int nextEvent(lua_State* L) {
free(event.data.thread.error);
return 3;
#ifdef LOVR_ENABLE_HEADSET
case EVENT_CONTROLLER_ADDED:
case EVENT_CONTROLLER_REMOVED:
luax_pushobject(L, event.data.controller.controller);
lovrRelease(Controller, event.data.controller.controller);
return 2;
case EVENT_CONTROLLER_PRESSED:
case EVENT_CONTROLLER_RELEASED:
luax_pushobject(L, event.data.controller.controller);
lua_pushstring(L, ControllerButtons[event.data.controller.button]);
return 3;
#endif
case EVENT_CUSTOM:
for (int i = 0; i < event.data.custom.count; i++) {
Variant* variant = &event.data.custom.data[i];

58
src/api/headset.c
View File

@ -5,40 +5,12 @@
#include "data/modelData.h"
#include "graphics/model.h"
#include "graphics/texture.h"
#include "lib/math.h"
#include "lib/maf.h"
#if defined(EMSCRIPTEN) || defined(LOVR_USE_OCULUS_MOBILE)
#define LOVR_HEADSET_HELPER_USES_REGISTRY
#endif
const char* ControllerAxes[] = {
[CONTROLLER_AXIS_TRIGGER] = "trigger",
[CONTROLLER_AXIS_GRIP] = "grip",
[CONTROLLER_AXIS_TOUCHPAD_X] = "touchx",
[CONTROLLER_AXIS_TOUCHPAD_Y] = "touchy",
NULL
};
const char* ControllerButtons[] = {
[CONTROLLER_BUTTON_SYSTEM] = "system",
[CONTROLLER_BUTTON_MENU] = "menu",
[CONTROLLER_BUTTON_TRIGGER] = "trigger",
[CONTROLLER_BUTTON_GRIP] = "grip",
[CONTROLLER_BUTTON_TOUCHPAD] = "touchpad",
[CONTROLLER_BUTTON_A] = "a",
[CONTROLLER_BUTTON_B] = "b",
[CONTROLLER_BUTTON_X] = "x",
[CONTROLLER_BUTTON_Y] = "y",
NULL
};
const char* ControllerHands[] = {
[HAND_UNKNOWN] = "unknown",
[HAND_LEFT] = "left",
[HAND_RIGHT] = "right",
NULL
};
const char* HeadsetDrivers[] = {
[DRIVER_DESKTOP] = "desktop",
[DRIVER_OCULUS] = "oculus",
@ -48,12 +20,6 @@ const char* HeadsetDrivers[] = {
NULL
};
const char* HeadsetEyes[] = {
[EYE_LEFT] = "left",
[EYE_RIGHT] = "right",
NULL
};
const char* HeadsetOrigins[] = {
[ORIGIN_HEAD] = "head",
[ORIGIN_FLOOR] = "floor",
@ -419,24 +385,6 @@ int l_lovrHeadsetNewModel(lua_State* L) {
return 0;
}
static int l_lovrHeadsetGetControllers(lua_State* L) {
uint8_t count;
Controller** controllers = lovrHeadsetDriver->getControllers(&count);
lua_createtable(L, count, 0);
for (uint8_t i = 0; i < count; i++) {
luax_pushobject(L, controllers[i]);
lua_rawseti(L, -2, i + 1);
}
return 1;
}
static int l_lovrHeadsetGetControllerCount(lua_State* L) {
uint8_t count;
lovrHeadsetDriver->getControllers(&count);
lua_pushnumber(L, count);
return 1;
}
static int l_lovrHeadsetRenderTo(lua_State* L) {
lua_settop(L, 1);
luaL_checktype(L, 1, LUA_TFUNCTION);
@ -491,7 +439,6 @@ static const luaL_Reg lovrHeadset[] = {
{ "getPose", l_lovrHeadsetGetPose },
{ "getPosition", l_lovrHeadsetGetPosition },
{ "getOrientation", l_lovrHeadsetGetOrientation },
{ "getDirection", l_lovrHeadsetGetDirection },
{ "getVelocity", l_lovrHeadsetGetVelocity },
{ "getAngularVelocity", l_lovrHeadsetGetAngularVelocity },
{ "isDown", l_lovrHeadsetIsDown },
@ -499,8 +446,6 @@ static const luaL_Reg lovrHeadset[] = {
{ "getAxis", l_lovrHeadsetGetAxis },
{ "vibrate", l_lovrHeadsetVibrate },
{ "newModel", l_lovrHeadsetNewModel },
{ "getControllers", l_lovrHeadsetGetControllers },
{ "getControllerCount", l_lovrHeadsetGetControllerCount },
{ "renderTo", l_lovrHeadsetRenderTo },
{ "update", l_lovrHeadsetUpdate },
{ "getMirrorTexture", l_lovrHeadsetGetMirrorTexture },
@ -510,7 +455,6 @@ static const luaL_Reg lovrHeadset[] = {
int luaopen_lovr_headset(lua_State* L) {
lua_newtable(L);
luaL_register(L, NULL, lovrHeadset);
luax_registertype(L, Controller);
luax_pushconf(L);
lua_getfield(L, -1, "headset");

108
src/api/types/controller.c
View File

@ -1,108 +0,0 @@
#include "api.h"
#include "api/headset.h"
#include "api/math.h"
#include "headset/headset.h"
#include "data/modelData.h"
#include "graphics/model.h"
static int l_lovrControllerIsConnected(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
lua_pushboolean(L, lovrHeadsetDriver->controllerIsConnected(controller));
return 1;
}
static int l_lovrControllerGetPose(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
luax_pushpath(L, controller->path);
lua_replace(L, 1);
return l_lovrHeadsetGetPose(L);
}
static int l_lovrControllerGetPosition(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
luax_pushpath(L, controller->path);
return l_lovrHeadsetGetPosition(L);
}
static int l_lovrControllerGetOrientation(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
luax_pushpath(L, controller->path);
return l_lovrHeadsetGetOrientation(L);
}
static int l_lovrControllerGetDirection(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
float x, y, z, angle, ax, ay, az;
lovrHeadsetDriver->controllerGetPose(controller, &x, &y, &z, &angle, &ax, &ay, &az);
float q[4];
quat_fromAngleAxis(q, angle, ax, ay, az);
float v[3] = { 0.f, 0.f, -1.f };
quat_rotate(q, v);
lua_pushnumber(L, v[0]);
lua_pushnumber(L, v[1]);
lua_pushnumber(L, v[2]);
return 3;
}
static int l_lovrControllerGetVelocity(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
luax_pushpath(L, controller->path);
return l_lovrHeadsetGetVelocity(L);
}
static int l_lovrControllerGetAngularVelocity(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
luax_pushpath(L, controller->path);
return l_lovrHeadsetGetAngularVelocity(L);
}
static int l_lovrControllerGetAxis(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
luax_pushpath(L, controller->path);
lua_replace(L, 1);
return l_lovrHeadsetGetAxis(L);
}
static int l_lovrControllerIsDown(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
luax_pushpath(L, controller->path);
lua_replace(L, 1);
return l_lovrHeadsetIsDown(L);
}
static int l_lovrControllerIsTouched(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
luax_pushpath(L, controller->path);
lua_replace(L, 1);
return l_lovrHeadsetIsTouched(L);
}
static int l_lovrControllerVibrate(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
luax_pushpath(L, controller->path);
lua_replace(L, 1);
return l_lovrHeadsetVibrate(L);
}
static int l_lovrControllerNewModel(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
luax_pushpath(L, controller->path);
lua_replace(L, 1);
return l_lovrHeadsetNewModel(L);
}
const luaL_Reg lovrController[] = {
{ "isConnected", l_lovrControllerIsConnected },
{ "getPose", l_lovrControllerGetPose },
{ "getPosition", l_lovrControllerGetPosition },
{ "getOrientation", l_lovrControllerGetOrientation },
{ "getDirection", l_lovrControllerGetDirection },
{ "getVelocity", l_lovrControllerGetVelocity },
{ "getAngularVelocity", l_lovrControllerGetAngularVelocity },
{ "getAxis", l_lovrControllerGetAxis },
{ "isDown", l_lovrControllerIsDown },
{ "isTouched", l_lovrControllerIsTouched },
{ "vibrate", l_lovrControllerVibrate },
{ "newModel", l_lovrControllerNewModel },
{ NULL, NULL }
};

15
src/event/event.h
View File

@ -1,12 +1,11 @@
#include "headset/headset.h"
#include "lib/vec/vec.h"
#include "types.h"
#include <stdbool.h>
#pragma once
#define MAX_EVENT_NAME_LENGTH 32
struct Controller;
struct Thread;
typedef enum {
@ -14,12 +13,6 @@ typedef enum {
EVENT_FOCUS,
EVENT_MOUNT,
EVENT_THREAD_ERROR,
#ifdef LOVR_ENABLE_HEADSET
EVENT_CONTROLLER_ADDED,
EVENT_CONTROLLER_REMOVED,
EVENT_CONTROLLER_PRESSED,
EVENT_CONTROLLER_RELEASED,
#endif
EVENT_CUSTOM
} EventType;
@ -57,11 +50,6 @@ typedef struct {
char* error;
} ThreadEvent;
typedef struct {
struct Controller* controller;
ControllerButton button;
} ControllerEvent;
typedef struct {
char name[MAX_EVENT_NAME_LENGTH];
Variant data[4];
@ -72,7 +60,6 @@ typedef union {
QuitEvent quit;
BoolEvent boolean;
ThreadEvent thread;
ControllerEvent controller;
CustomEvent custom;
} EventData;

41
src/headset/desktop.c
View File

@ -1,4 +1,4 @@
#include "event/event.h"
#include "headset/headset.h"
#include "graphics/graphics.h"
#include "lib/maf.h"
#include "platform.h"
@ -11,8 +11,6 @@ static struct {
HeadsetType type;
float offset;
vec_controller_t controllers;
float clipNear;
float clipFar;
@ -29,41 +27,15 @@ static struct {
double prevCursorY;
} state;
static void onMouseButton(MouseButton button, ButtonAction action) {
if (button == MOUSE_RIGHT) {
Controller* controller; int i;
vec_foreach(&state.controllers, controller, i) {
lovrEventPush((Event) {
.type = action == BUTTON_PRESSED ? EVENT_CONTROLLER_PRESSED : EVENT_CONTROLLER_RELEASED,
.data.controller = { controller, CONTROLLER_BUTTON_TRIGGER }
});
}
}
}
static bool desktopInit(float offset, int msaa) {
state.offset = offset;
state.clipNear = 0.1f;
state.clipFar = 100.f;
mat4_identity(state.transform);
vec_init(&state.controllers);
Controller* controller = lovrAlloc(Controller);
controller->id = 0;
controller->path = MAKE_PATH(PATH_HANDS, PATH_LEFT);
vec_push(&state.controllers, controller);
lovrPlatformOnMouseButton(onMouseButton);
return true;
}
static void desktopDestroy(void) {
Controller *controller; int i;
vec_foreach(&state.controllers, controller, i) {
lovrRelease(Controller, controller);
}
vec_deinit(&state.controllers);
memset(&state, 0, sizeof(state));
}
@ -176,15 +148,6 @@ static ModelData* desktopNewModelData(Path path) {
return NULL;
}
static Controller** desktopGetControllers(uint8_t* count) {
*count = state.controllers.length;
return state.controllers.data;
}
static bool desktopControllerIsConnected(Controller* controller) {
return true;
}
static void desktopRenderTo(void (*callback)(void*), void* userdata) {
uint32_t width, height;
desktopGetDisplayDimensions(&width, &height);
@ -281,8 +244,6 @@ HeadsetInterface lovrHeadsetDesktopDriver = {
.getAxis = desktopGetAxis,
.vibrate = desktopVibrate,
.newModelData = desktopNewModelData,
.getControllers = desktopGetControllers,
.controllerIsConnected = desktopControllerIsConnected,
.renderTo = desktopRenderTo,
.update = desktopUpdate
};

44
src/headset/headset.h
View File

@ -9,10 +9,9 @@ struct ModelData;
struct Texture;
typedef enum {
EYE_BOTH = -1,
EYE_LEFT,
EYE_RIGHT
} HeadsetEye;
SIDE_LEFT,
SIDE_RIGHT
} Chirality;
typedef enum {
ORIGIN_HEAD,
@ -61,40 +60,6 @@ typedef union {
#define PATH_EQ(p, ...) ((p).u64 == MAKE_PATH(__VA_ARGS__).u64)
#define PATH_STARTS_WITH(p, ...) ((MAKE_PATH(__VA_ARGS__).u64 ^ p.u64 & MAKE_PATH(__VA_ARGS__).u64) == 0)
typedef enum {
CONTROLLER_AXIS_TRIGGER,
CONTROLLER_AXIS_GRIP,
CONTROLLER_AXIS_TOUCHPAD_X,
CONTROLLER_AXIS_TOUCHPAD_Y
} ControllerAxis;
typedef enum {
CONTROLLER_BUTTON_SYSTEM,
CONTROLLER_BUTTON_MENU,
CONTROLLER_BUTTON_TRIGGER,
CONTROLLER_BUTTON_GRIP,
CONTROLLER_BUTTON_TOUCHPAD,
CONTROLLER_BUTTON_A,
CONTROLLER_BUTTON_B,
CONTROLLER_BUTTON_X,
CONTROLLER_BUTTON_Y,
CONTROLLER_BUTTON_UNKNOWN // Must be last item
} ControllerButton;
typedef enum {
HAND_UNKNOWN,
HAND_LEFT,
HAND_RIGHT
} ControllerHand;
typedef struct Controller {
Ref ref;
uint32_t id;
Path path;
} Controller;
typedef vec_t(Controller*) vec_controller_t;
// The interface implemented by headset backends
// - The 'next' pointer is used internally to create a linked list of tracking drivers.
// - If the renderTo function is implemented, the backend is a "display" backend. Only the first
@ -122,8 +87,6 @@ typedef struct HeadsetInterface {
int (*getAxis)(Path path, float* x, float* y, float* z);
bool (*vibrate)(Path path, float strength, float duration, float frequency);
struct ModelData* (*newModelData)(Path path);
Controller** (*getControllers)(uint8_t* count);
bool (*controllerIsConnected)(Controller* controller);
void (*renderTo)(void (*callback)(void*), void* userdata);
struct Texture* (*getMirrorTexture)(void);
void (*update)(float dt);
@ -145,4 +108,3 @@ extern HeadsetInterface* lovrHeadsetTrackingDrivers;
bool lovrHeadsetInit(HeadsetDriver* drivers, int count, float offset, int msaa);
void lovrHeadsetDestroy(void);
void lovrControllerDestroy(void* ref);

139
src/headset/openvr.c
View File

@ -1,3 +1,4 @@
#include "headset/headset.h"
#include "event/event.h"
#include "graphics/graphics.h"
#include "graphics/canvas.h"
@ -37,7 +38,6 @@ typedef struct {
RenderModel_TextureMap_t* deviceTextures[16];
Canvas* canvas;
vec_float_t boundsGeometry;
vec_controller_t controllers;
HeadsetType type;
float clipNear;
float clipFar;
@ -70,57 +70,6 @@ static TrackedDeviceIndex_t getDeviceIndexForPath(Path path) {
}
}
static bool isController(TrackedDeviceIndex_t id) {
return state.system->IsTrackedDeviceConnected(id) &&
(state.system->GetTrackedDeviceClass(id) == ETrackedDeviceClass_TrackedDeviceClass_Controller ||
state.system->GetTrackedDeviceClass(id) == ETrackedDeviceClass_TrackedDeviceClass_GenericTracker);
}
static ControllerHand getControllerHand(Controller* controller) {
switch (state.system->GetControllerRoleForTrackedDeviceIndex(controller->id)) {
case ETrackedControllerRole_TrackedControllerRole_LeftHand: return HAND_LEFT;
case ETrackedControllerRole_TrackedControllerRole_RightHand: return HAND_RIGHT;
default: return HAND_UNKNOWN;
}
}
static ControllerButton getButton(uint32_t button, ControllerHand hand) {
switch (state.type) {
case HEADSET_RIFT:
switch (button) {
case EVRButtonId_k_EButton_Axis1: return CONTROLLER_BUTTON_TRIGGER;
case EVRButtonId_k_EButton_Axis2: return CONTROLLER_BUTTON_GRIP;
case EVRButtonId_k_EButton_Axis0: return CONTROLLER_BUTTON_TOUCHPAD;
case EVRButtonId_k_EButton_A:
switch (hand) {
case HAND_LEFT: return CONTROLLER_BUTTON_X;
case HAND_RIGHT: return CONTROLLER_BUTTON_A;
default: return CONTROLLER_BUTTON_UNKNOWN;
}
case EVRButtonId_k_EButton_ApplicationMenu:
switch (hand) {
case HAND_LEFT: return CONTROLLER_BUTTON_Y;
case HAND_RIGHT: return CONTROLLER_BUTTON_B;
default: return CONTROLLER_BUTTON_UNKNOWN;
}
default: return CONTROLLER_BUTTON_UNKNOWN;
}
break;
default:
switch (button) {
case EVRButtonId_k_EButton_System: return CONTROLLER_BUTTON_SYSTEM;
case EVRButtonId_k_EButton_ApplicationMenu: return CONTROLLER_BUTTON_MENU;
case EVRButtonId_k_EButton_SteamVR_Trigger: return CONTROLLER_BUTTON_TRIGGER;
case EVRButtonId_k_EButton_Grip: return CONTROLLER_BUTTON_GRIP;
case EVRButtonId_k_EButton_SteamVR_Touchpad: return CONTROLLER_BUTTON_TOUCHPAD;
default: return CONTROLLER_BUTTON_UNKNOWN;
}
}
return CONTROLLER_BUTTON_UNKNOWN;
}
static bool getButtonState(Path path, bool touch, bool* value) {
if (!PATH_EQ(path, PATH_HANDS, PATH_LEFT) && !PATH_EQ(path, PATH_HANDS, PATH_RIGHT)) {
return false;
@ -138,10 +87,10 @@ static bool getButtonState(Path path, bool touch, bool* value) {
uint64_t mask = touch ? input.ulButtonTouched : input.ulButtonPressed;
ControllerHand hand = HAND_UNKNOWN;
Chirality hand = SIDE_LEFT;
switch (state.system->GetControllerRoleForTrackedDeviceIndex(deviceIndex)) {
case ETrackedControllerRole_TrackedControllerRole_LeftHand: return HAND_LEFT;
case ETrackedControllerRole_TrackedControllerRole_RightHand: return HAND_RIGHT;
case ETrackedControllerRole_TrackedControllerRole_LeftHand: hand = SIDE_LEFT; break;
case ETrackedControllerRole_TrackedControllerRole_RightHand: hand = SIDE_RIGHT; break;
default: break;
}
@ -161,19 +110,19 @@ static bool getButtonState(Path path, bool touch, bool* value) {
return true;
case PATH_A:
*value = hand == HAND_RIGHT && (mask >> EVRButtonId_k_EButton_A) & 1;
*value = hand == SIDE_RIGHT && (mask >> EVRButtonId_k_EButton_A) & 1;
return true;
case PATH_B:
*value = hand == HAND_RIGHT && (mask >> EVRButtonId_k_EButton_ApplicationMenu) & 1;
*value = hand == SIDE_RIGHT && (mask >> EVRButtonId_k_EButton_ApplicationMenu) & 1;
return true;
case PATH_X:
*value = hand == HAND_LEFT && (mask >> EVRButtonId_k_EButton_A) & 1;
*value = hand == SIDE_LEFT && (mask >> EVRButtonId_k_EButton_A) & 1;
return true;
case PATH_Y:
*value = hand == HAND_LEFT && (mask >> EVRButtonId_k_EButton_ApplicationMenu) & 1;
*value = hand == SIDE_LEFT && (mask >> EVRButtonId_k_EButton_ApplicationMenu) & 1;
return true;
default: return false;
@ -242,15 +191,6 @@ static bool openvrInit(float offset, int msaa) {
state.msaa = msaa;
vec_init(&state.boundsGeometry);
vec_init(&state.controllers);
for (uint32_t i = 0; i < k_unMaxTrackedDeviceCount; i++) {
if (isController(i)) {
Controller* controller = lovrAlloc(Controller);
controller->id = i;
vec_push(&state.controllers, controller);
}
}
return true;
}
@ -266,12 +206,7 @@ static void openvrDestroy(void) {
state.deviceModels[i] = NULL;
state.deviceTextures[i] = NULL;
}
Controller* controller; int i;
vec_foreach(&state.controllers, controller, i) {
lovrRelease(Controller, controller);
}
vec_deinit(&state.boundsGeometry);
vec_deinit(&state.controllers);
VR_ShutdownInternal();
memset(&state, 0, sizeof(HeadsetState));
}
@ -555,15 +490,6 @@ static ModelData* openvrNewModelData(Path path) {
return model;
}
static Controller** openvrGetControllers(uint8_t* count) {
*count = state.controllers.length;
return state.controllers.data;
}
static bool openvrControllerIsConnected(Controller* controller) {
return state.system->IsTrackedDeviceConnected(controller->id);
}
static void openvrRenderTo(void (*callback)(void*), void* userdata) {
if (!state.canvas) {
uint32_t width, height;
@ -608,56 +534,9 @@ static void openvrRenderTo(void (*callback)(void*), void* userdata) {
static void openvrUpdate(float dt) {
state.compositor->WaitGetPoses(state.poses, 16, NULL, 0);
// Poll for new events after waiting for poses (to get as many events as possible)
struct VREvent_t vrEvent;
while (state.system->PollNextEvent(&vrEvent, sizeof(vrEvent))) {
switch (vrEvent.eventType) {
case EVREventType_VREvent_TrackedDeviceActivated: {
uint32_t id = vrEvent.trackedDeviceIndex;
if (isController(id)) {
Controller* controller = lovrAlloc(Controller);
controller->id = id;
vec_push(&state.controllers, controller);
lovrRetain(controller);
lovrEventPush((Event) { .type = EVENT_CONTROLLER_ADDED, .data.controller = { controller, 0 } });
}
break;
}
case EVREventType_VREvent_TrackedDeviceDeactivated:
for (int i = 0; i < state.controllers.length; i++) {
Controller* controller = state.controllers.data[i];
if (controller->id == vrEvent.trackedDeviceIndex) {
lovrRetain(controller);
lovrEventPush((Event) { .type = EVENT_CONTROLLER_REMOVED, .data.controller = { controller, 0 } });
vec_swapsplice(&state.controllers, i, 1);
lovrRelease(Controller, controller);
break;
}
}
break;
case EVREventType_VREvent_ButtonPress:
case EVREventType_VREvent_ButtonUnpress: {
bool isPress = vrEvent.eventType == EVREventType_VREvent_ButtonPress;
if (vrEvent.trackedDeviceIndex == HEADSET_INDEX && vrEvent.data.controller.button == EVRButtonId_k_EButton_ProximitySensor) {
lovrEventPush((Event) { .type = EVENT_MOUNT, .data.boolean = { isPress } });
break;
}
for (int i = 0; i < state.controllers.length; i++) {
Controller* controller = state.controllers.data[i];
if (controller->id == vrEvent.trackedDeviceIndex) {
ControllerButton button = getButton(vrEvent.data.controller.button, getControllerHand(controller));
EventType type = isPress ? EVENT_CONTROLLER_PRESSED : EVENT_CONTROLLER_RELEASED;
lovrEventPush((Event) { .type = type, .data.controller = { controller, button } });
break;
}
}
break;
}
case EVREventType_VREvent_InputFocusCaptured:
case EVREventType_VREvent_InputFocusReleased: {
bool isFocused = vrEvent.eventType == EVREventType_VREvent_InputFocusReleased;
@ -694,8 +573,6 @@ HeadsetInterface lovrHeadsetOpenVRDriver = {
.getAxis = openvrGetAxis,
.vibrate = openvrVibrate,
.newModelData = openvrNewModelData,
.getControllers = openvrGetControllers,
.controllerIsConnected = openvrControllerIsConnected,
.renderTo = openvrRenderTo,
.getMirrorTexture = openvrGetMirrorTexture,
.update = openvrUpdate

17
src/resources/boot.lua
View File

@ -1,15 +1,6 @@
lovr = require 'lovr'
local function nogame()
local logo, controllers
local function refreshControllers()
controllers = {}
if not lovr.headset then return end
for _, controller in pairs(lovr.headset.getControllers()) do
controllers[controller] = controller:newModel()
end
end
function lovr.conf(t)
t.modules.audio = false
t.modules.math = false
@ -26,15 +17,10 @@ local function nogame()
local texture = lovr.graphics.newTexture(lovr.data.newBlob(lovr._logo, 'logo.png'))
logo = lovr.graphics.newMaterial(texture)
lovr.graphics.setBackgroundColor(.960, .988, 1.0)
refreshControllers()
end
function lovr.draw()
lovr.graphics.setColor(1.0, 1.0, 1.0)
for controller, model in pairs(controllers) do
local x, y, z = controller:getPosition()
model:draw(x, y, z, 1, controller:getOrientation())
end
local padding = .1
local font = lovr.graphics.getFont()
local fade = .315 + .685 * math.abs(math.sin(lovr.timer.getTime() * 2))
@ -47,9 +33,6 @@ local function nogame()
lovr.graphics.print('No game :(', -.01, subtitlePosition, -3, .15, 0, 0, 1, 0, nil, 'center', 'top')
lovr.graphics.setColor(1, 1, 1)
end
lovr.controlleradded = refreshControllers
lovr.controllerremoved = refreshControllers
end
-- Note: Cannot be overloaded

1251
src/resources/boot.lua.h
View File

File diff suppressed because it is too large Load Diff