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

Simplify headset structure;

This commit is contained in:
bjorn 2018-04-28 16:59:53 -07:00 committed by bjornbytes
parent b8eb2799f9
commit c767e9c165
7 changed files with 45 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
src/api/headset.c
View File

@ -101,7 +101,7 @@ int l_lovrHeadsetInit(lua_State* L) {
}
lovrHeadsetInit(drivers.data, drivers.length, offset);
lovrHeadsetSetMirrored(mirror);
lovrHeadsetDriver->setMirrored(mirror);
vec_deinit(&drivers);
lua_pop(L, 2);
@ -112,58 +112,53 @@ int l_lovrHeadsetInit(lua_State* L) {
}
int l_lovrHeadsetGetDriver(lua_State* L) {
const HeadsetDriver* driver = lovrHeadsetGetDriver();
if (driver) {
luax_pushenum(L, &HeadsetDrivers, *driver);
} else {
lua_pushnil(L);
}
luax_pushenum(L, &HeadsetDrivers, lovrHeadsetDriver->driverType);
return 1;
}
int l_lovrHeadsetGetType(lua_State* L) {
luax_pushenum(L, &HeadsetTypes, lovrHeadsetGetType());
luax_pushenum(L, &HeadsetTypes, lovrHeadsetDriver->getType());
return 1;
}
int l_lovrHeadsetGetOriginType(lua_State* L) {
luax_pushenum(L, &HeadsetOrigins, lovrHeadsetGetOriginType());
luax_pushenum(L, &HeadsetOrigins, lovrHeadsetDriver->getOriginType());
return 1;
}
int l_lovrHeadsetIsMounted(lua_State* L) {
lua_pushboolean(L, lovrHeadsetIsMounted());
lua_pushboolean(L, lovrHeadsetDriver->isMounted());
return 1;
}
int l_lovrHeadsetIsMirrored(lua_State* L) {
lua_pushboolean(L, lovrHeadsetIsMirrored());
lua_pushboolean(L, lovrHeadsetDriver->isMirrored());
return 1;
}
int l_lovrHeadsetSetMirrored(lua_State* L) {
int mirror = lua_toboolean(L, 1);
lovrHeadsetSetMirrored(mirror);
lovrHeadsetDriver->setMirrored(mirror);
return 0;
}
int l_lovrHeadsetGetDisplayWidth(lua_State* L) {
int width;
lovrHeadsetGetDisplayDimensions(&width, NULL);
lovrHeadsetDriver->getDisplayDimensions(&width, NULL);
lua_pushnumber(L, width);
return 1;
}
int l_lovrHeadsetGetDisplayHeight(lua_State* L) {
int height;
lovrHeadsetGetDisplayDimensions(NULL, &height);
lovrHeadsetDriver->getDisplayDimensions(NULL, &height);
lua_pushnumber(L, height);
return 1;
}
int l_lovrHeadsetGetDisplayDimensions(lua_State* L) {
int width, height;
lovrHeadsetGetDisplayDimensions(&width, &height);
lovrHeadsetDriver->getDisplayDimensions(&width, &height);
lua_pushnumber(L, width);
lua_pushnumber(L, height);
return 2;
@ -171,7 +166,7 @@ int l_lovrHeadsetGetDisplayDimensions(lua_State* L) {
int l_lovrHeadsetGetClipDistance(lua_State* L) {
float clipNear, clipFar;
lovrHeadsetGetClipDistance(&clipNear, &clipFar);
lovrHeadsetDriver->getClipDistance(&clipNear, &clipFar);
lua_pushnumber(L, clipNear);
lua_pushnumber(L, clipFar);
return 2;
@ -180,32 +175,32 @@ int l_lovrHeadsetGetClipDistance(lua_State* L) {
int l_lovrHeadsetSetClipDistance(lua_State* L) {
float clipNear = luaL_checknumber(L, 1);
float clipFar = luaL_checknumber(L, 2);
lovrHeadsetSetClipDistance(clipNear, clipFar);
lovrHeadsetDriver->setClipDistance(clipNear, clipFar);
return 0;
}
int l_lovrHeadsetGetBoundsWidth(lua_State* L) {
lua_pushnumber(L, lovrHeadsetGetBoundsWidth());
lua_pushnumber(L, lovrHeadsetDriver->getBoundsWidth());
return 1;
}
int l_lovrHeadsetGetBoundsDepth(lua_State* L) {
lua_pushnumber(L, lovrHeadsetGetBoundsDepth());
lua_pushnumber(L, lovrHeadsetDriver->getBoundsDepth());
return 1;
}
int l_lovrHeadsetGetBoundsDimensions(lua_State* L) {
lua_pushnumber(L, lovrHeadsetGetBoundsWidth());
lua_pushnumber(L, lovrHeadsetGetBoundsDepth());
lua_pushnumber(L, lovrHeadsetDriver->getBoundsWidth());
lua_pushnumber(L, lovrHeadsetDriver->getBoundsDepth());
return 2;
}
static void luax_getPose(lua_State* L, float* x, float* y, float* z, float* angle, float* ax, float* ay, float* az) {
if (lua_type(L, 1) == LUA_TSTRING) {
HeadsetEye eye = *(HeadsetEye*) luax_checkenum(L, 1, &HeadsetEyes, "eye");
lovrHeadsetGetEyePose(eye, x, y, z, angle, ax, ay, az);
lovrHeadsetDriver->getEyePose(eye, x, y, z, angle, ax, ay, az);
} else {
lovrHeadsetGetPose(x, y, z, angle, ax, ay, az);
lovrHeadsetDriver->getPose(x, y, z, angle, ax, ay, az);
}
}
@ -243,7 +238,7 @@ int l_lovrHeadsetGetOrientation(lua_State* L) {
int l_lovrHeadsetGetVelocity(lua_State* L) {
float x, y, z;
lovrHeadsetGetVelocity(&x, &y, &z);
lovrHeadsetDriver->getVelocity(&x, &y, &z);
lua_pushnumber(L, x);
lua_pushnumber(L, y);
lua_pushnumber(L, z);
@ -252,7 +247,7 @@ int l_lovrHeadsetGetVelocity(lua_State* L) {
int l_lovrHeadsetGetAngularVelocity(lua_State* L) {
float x, y, z;
lovrHeadsetGetAngularVelocity(&x, &y, &z);
lovrHeadsetDriver->getAngularVelocity(&x, &y, &z);
lua_pushnumber(L, x);
lua_pushnumber(L, y);
lua_pushnumber(L, z);
@ -260,7 +255,7 @@ int l_lovrHeadsetGetAngularVelocity(lua_State* L) {
}
int l_lovrHeadsetGetControllers(lua_State* L) {
vec_controller_t* controllers = lovrHeadsetGetControllers();
vec_controller_t* controllers = lovrHeadsetDriver->getControllers();
if (!controllers) {
lua_newtable(L);
return 1;
@ -276,7 +271,7 @@ int l_lovrHeadsetGetControllers(lua_State* L) {
}
int l_lovrHeadsetGetControllerCount(lua_State* L) {
vec_controller_t* controllers = lovrHeadsetGetControllers();
vec_controller_t* controllers = lovrHeadsetDriver->getControllers();
if (controllers) {
lua_pushnumber(L, controllers->length);
} else {
@ -295,13 +290,13 @@ int l_lovrHeadsetRenderTo(lua_State* L) {
headsetRenderData.ref = luaL_ref(L, LUA_REGISTRYINDEX);
headsetRenderData.L = L;
lovrHeadsetRenderTo(renderHelper, &headsetRenderData);
lovrHeadsetDriver->renderTo(renderHelper, &headsetRenderData);
return 0;
}
int l_lovrHeadsetUpdate(lua_State* L) {
float dt = luaL_checknumber(L, 1);
lovrHeadsetUpdate(dt);
lovrHeadsetDriver->update(dt);
return 0;
}

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

@ -5,13 +5,13 @@
int l_lovrControllerIsConnected(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
lua_pushboolean(L, lovrHeadsetControllerIsConnected(controller));
lua_pushboolean(L, lovrHeadsetDriver->controllerIsConnected(controller));
return 1;
}
int l_lovrControllerGetHand(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
ControllerHand hand = lovrHeadsetControllerGetHand(controller);
ControllerHand hand = lovrHeadsetDriver->controllerGetHand(controller);
luax_pushenum(L, &ControllerHands, hand);
return 1;
}
@ -19,7 +19,7 @@ int l_lovrControllerGetHand(lua_State* L) {
int l_lovrControllerGetPose(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
float x, y, z, angle, ax, ay, az;
lovrHeadsetControllerGetPose(controller, &x, &y, &z, &angle, &ax, &ay, &az);
lovrHeadsetDriver->controllerGetPose(controller, &x, &y, &z, &angle, &ax, &ay, &az);
lua_pushnumber(L, x);
lua_pushnumber(L, y);
lua_pushnumber(L, z);
@ -33,7 +33,7 @@ int l_lovrControllerGetPose(lua_State* L) {
int l_lovrControllerGetPosition(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
float x, y, z, angle, ax, ay, az;
lovrHeadsetControllerGetPose(controller, &x, &y, &z, &angle, &ax, &ay, &az);
lovrHeadsetDriver->controllerGetPose(controller, &x, &y, &z, &angle, &ax, &ay, &az);
lua_pushnumber(L, x);
lua_pushnumber(L, y);
lua_pushnumber(L, z);
@ -43,7 +43,7 @@ int l_lovrControllerGetPosition(lua_State* L) {
int l_lovrControllerGetOrientation(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
float x, y, z, angle, ax, ay, az;
lovrHeadsetControllerGetPose(controller, &x, &y, &z, &angle, &ax, &ay, &az);
lovrHeadsetDriver->controllerGetPose(controller, &x, &y, &z, &angle, &ax, &ay, &az);
lua_pushnumber(L, angle);
lua_pushnumber(L, ax);
lua_pushnumber(L, ay);
@ -54,21 +54,21 @@ int l_lovrControllerGetOrientation(lua_State* L) {
int l_lovrControllerGetAxis(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
ControllerAxis* axis = (ControllerAxis*) luax_checkenum(L, 2, &ControllerAxes, "controller axis");
lua_pushnumber(L, lovrHeadsetControllerGetAxis(controller, *axis));
lua_pushnumber(L, lovrHeadsetDriver->controllerGetAxis(controller, *axis));
return 1;
}
int l_lovrControllerIsDown(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
ControllerButton* button = (ControllerButton*) luax_checkenum(L, 2, &ControllerButtons, "controller button");
lua_pushboolean(L, lovrHeadsetControllerIsDown(controller, *button));
lua_pushboolean(L, lovrHeadsetDriver->controllerIsDown(controller, *button));
return 1;
}
int l_lovrControllerIsTouched(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
ControllerButton* button = (ControllerButton*) luax_checkenum(L, 2, &ControllerButtons, "controller button");
lua_pushboolean(L, lovrHeadsetControllerIsTouched(controller, *button));
lua_pushboolean(L, lovrHeadsetDriver->controllerIsTouched(controller, *button));
return 1;
}
@ -76,13 +76,13 @@ int l_lovrControllerVibrate(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
float duration = luaL_optnumber(L, 2, .5);
float power = luaL_optnumber(L, 3, 1);
lovrHeadsetControllerVibrate(controller, duration, power);
lovrHeadsetDriver->controllerVibrate(controller, duration, power);
return 0;
}
int l_lovrControllerNewModel(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
ModelData* modelData = lovrHeadsetControllerNewModelData(controller);
ModelData* modelData = lovrHeadsetDriver->controllerNewModelData(controller);
if (modelData) {
Model* model = lovrModelCreate(modelData);
luax_pushtype(L, Model, model);

7
src/headset/fake.c
View File

@ -12,7 +12,6 @@
#include <stdbool.h>
typedef struct {
bool initialized;
HeadsetType type;
bool mirrored;
float offset;
@ -144,7 +143,6 @@ static void check_window_existance() {
}
static bool fakeInit(float offset) {
if (state.initialized) return true;
state.mirrored = true;
state.offset = offset;
@ -168,21 +166,16 @@ static bool fakeInit(float offset) {
state.mouselook = false;
state.hookedWindow = NULL;
state.initialized = true;
return true;
}
static void fakeDestroy() {
if (!state.initialized) return;
int i;
Controller *controller;
vec_foreach(&state.controllers, controller, i) {
lovrRelease(controller);
}
vec_deinit(&state.controllers);
state.initialized = false;
memset(&state, 0, sizeof(FakeHeadsetState));
}

187
src/headset/headset.c
View File

@ -1,13 +1,12 @@
#include "headset/headset.h"
#include "event/event.h"
static HeadsetInterface* headset = NULL;
HeadsetInterface* lovrHeadsetDriver = NULL;
static bool initialized = false;
void lovrHeadsetInit(HeadsetDriver* drivers, int count, float offset) {
if (initialized) return;
initialized = true;
headset = NULL;
for (int i = 0; i < count; i++) {
HeadsetInterface* interface = NULL;
@ -23,192 +22,20 @@ void lovrHeadsetInit(HeadsetDriver* drivers, int count, float offset) {
}
if (interface && interface->init(offset)) {
headset = interface;
lovrHeadsetDriver = interface;
break;
}
}
lovrAssert(lovrHeadsetDriver, "No headset driver available, check t.headset.drivers in conf.lua");
}
void lovrHeadsetDestroy() {
if (!initialized) return;
initialized = false;
if (headset) {
headset->destroy();
headset = NULL;
}
}
const HeadsetDriver* lovrHeadsetGetDriver() {
if (!headset) {
lovrThrow("Headset is not initialized");
}
return &headset->driverType;
}
HeadsetType lovrHeadsetGetType() {
return headset ? headset->getType() : HEADSET_UNKNOWN;
}
HeadsetOrigin lovrHeadsetGetOriginType() {
return headset ? headset->getOriginType() : ORIGIN_HEAD;
}
bool lovrHeadsetIsMounted() {
return headset ? headset->isMounted() : false;
}
bool lovrHeadsetIsMirrored() {
return headset ? headset->isMirrored() : false;
}
void lovrHeadsetSetMirrored(bool mirror) {
if (headset) {
headset->setMirrored(mirror);
}
}
void lovrHeadsetGetDisplayDimensions(int* width, int* height) {
if (!headset) {
*width = *height = 0;
return;
}
headset->getDisplayDimensions(width, height);
}
void lovrHeadsetGetClipDistance(float* clipNear, float* clipFar) {
if (!headset) {
*clipNear = *clipFar = 0.f;
return;
}
headset->getClipDistance(clipNear, clipFar);
}
void lovrHeadsetSetClipDistance(float clipNear, float clipFar) {
if (headset) {
headset->setClipDistance(clipNear, clipFar);
}
}
float lovrHeadsetGetBoundsWidth() {
return headset ? headset->getBoundsWidth() : 0.f;
}
float lovrHeadsetGetBoundsDepth() {
return headset ? headset->getBoundsDepth() : 0.f;
}
void lovrHeadsetGetPose(float* x, float* y, float* z, float* angle, float* ax, float* ay, float* az) {
if (!headset) {
*x = *y = *z = *angle = *ax = *ay = *az = 0.f;
return;
}
headset->getPose(x, y, z, angle, ax, ay, az);
}
void lovrHeadsetGetEyePose(HeadsetEye eye, float* x, float* y, float* z, float* angle, float* ax, float* ay, float* az) {
if (!headset) {
*x = *y = *z = *angle = *ax = *ay = *az = 0.f;
return;
}
headset->getEyePose(eye, x, y, z, angle, ax, ay, az);
}
void lovrHeadsetGetVelocity(float* x, float* y, float* z) {
if (!headset) {
*x = *y = *z = 0.f;
return;
}
headset->getVelocity(x,y,z);
}
void lovrHeadsetGetAngularVelocity(float* x, float* y, float* z) {
if (!headset) {
*x = *y = *z = 0.f;
return;
}
headset->getAngularVelocity(x,y,z);
}
vec_controller_t* lovrHeadsetGetControllers() {
if (!headset) {
return NULL;
}
return headset->getControllers();
}
bool lovrHeadsetControllerIsConnected(Controller* controller) {
if (!headset || !controller) {
return false;
}
return headset->controllerIsConnected(controller);
}
ControllerHand lovrHeadsetControllerGetHand(Controller* controller) {
return headset ? headset->controllerGetHand(controller) : HAND_UNKNOWN;
}
void lovrHeadsetControllerGetPose(Controller* controller, float* x, float* y, float* z, float* angle, float* ax, float* ay, float* az) {
if (!headset || !controller) {
*x = *y = *z = *angle = *ax = *ay = *az = 0.f;
return;
}
headset->controllerGetPose(controller, x, y, z, angle, ax, ay, az);
}
float lovrHeadsetControllerGetAxis(Controller* controller, ControllerAxis axis) {
if (!headset || !controller) {
return 0.f;
}
return headset->controllerGetAxis(controller, axis);
}
bool lovrHeadsetControllerIsDown(Controller* controller, ControllerButton button) {
if (!headset || !controller) {
return false;
}
return headset->controllerIsDown(controller, button);
}
bool lovrHeadsetControllerIsTouched(Controller* controller, ControllerButton button) {
return (headset && controller) ? headset->controllerIsTouched(controller,button) : false;
}
void lovrHeadsetControllerVibrate(Controller* controller, float duration, float power) {
if (!headset || !controller) {
return;
}
headset->controllerVibrate(controller, duration, power);
}
ModelData* lovrHeadsetControllerNewModelData(Controller* controller) {
if (headset && controller) {
return headset->controllerNewModelData(controller);
} else {
return NULL;
}
}
void lovrHeadsetRenderTo(void (*callback)(void*), void* userdata) {
if (headset) {
headset->renderTo(callback, userdata);
}
}
void lovrHeadsetUpdate(float dt) {
if (headset && headset->update) {
headset->update(dt);
if (lovrHeadsetDriver) {
lovrHeadsetDriver->destroy();
lovrHeadsetDriver = NULL;
}
}

31
src/headset/headset.h
View File

@ -94,36 +94,13 @@ typedef struct {
void (*update)(float dt);
} HeadsetInterface;
// Headset implementations
// Available drivers
extern HeadsetInterface lovrHeadsetOpenVRDriver;
extern HeadsetInterface lovrHeadsetWebVRDriver;
extern HeadsetInterface lovrHeadsetFakeDriver;
// Active driver
extern HeadsetInterface* lovrHeadsetDriver;
void lovrHeadsetInit(HeadsetDriver* drivers, int count, float offset);
void lovrHeadsetDestroy();
const HeadsetDriver* lovrHeadsetGetDriver();
HeadsetType lovrHeadsetGetType();
HeadsetOrigin lovrHeadsetGetOriginType();
bool lovrHeadsetIsMounted();
bool lovrHeadsetIsMirrored();
void lovrHeadsetSetMirrored(bool mirror);
void lovrHeadsetGetDisplayDimensions(int* width, int* height);
void lovrHeadsetGetClipDistance(float* clipNear, float* clipFar);
void lovrHeadsetSetClipDistance(float clipNear, float clipFar);
float lovrHeadsetGetBoundsWidth();
float lovrHeadsetGetBoundsDepth();
void lovrHeadsetGetPose(float* x, float* y, float* z, float* angle, float* ax, float* ay, float* az);
void lovrHeadsetGetEyePose(HeadsetEye eye, float* x, float* y, float* z, float* angle, float* ax, float* ay, float* az);
void lovrHeadsetGetVelocity(float* x, float* y, float* z);
void lovrHeadsetGetAngularVelocity(float* x, float* y, float* z);
vec_controller_t* lovrHeadsetGetControllers();
bool lovrHeadsetControllerIsConnected(Controller* controller);
ControllerHand lovrHeadsetControllerGetHand(Controller* controller);
void lovrHeadsetControllerGetPose(Controller* controller, float* x, float* y, float* z, float* angle, float* ax, float* ay, float* az);
float lovrHeadsetControllerGetAxis(Controller* controller, ControllerAxis axis);
bool lovrHeadsetControllerIsDown(Controller* controller, ControllerButton button);
bool lovrHeadsetControllerIsTouched(Controller* controller, ControllerButton button);
void lovrHeadsetControllerVibrate(Controller* controller, float duration, float power);
ModelData* lovrHeadsetControllerNewModelData(Controller* controller);
void lovrHeadsetRenderTo(void (*callback)(void*), void* userdata);
void lovrHeadsetUpdate(float dt);

6
src/headset/openvr.c
View File

@ -27,7 +27,6 @@ extern bool VR_IsRuntimeInstalled();
static ControllerHand openvrControllerGetHand(Controller* controller);
typedef struct {
bool initialized;
bool isRendering;
bool isMirrored;
float offset;
@ -258,8 +257,6 @@ static void ensureCanvas() {
}
static bool openvrInit(float offset) {
if (state.initialized) return true;
if (!VR_IsHmdPresent() || !VR_IsRuntimeInstalled()) {
return false;
}
@ -331,13 +328,10 @@ static bool openvrInit(float offset) {
vec_init(&state.controllers);
openvrRefreshControllers();
lovrEventAddPump(openvrPoll);
state.initialized = true;
return true;
}
static void openvrDestroy() {
if (!state.initialized) return;
state.initialized = false;
lovrRelease(&state.canvas->texture);
for (int i = 0; i < 16; i++) {
if (state.deviceModels[i]) {

3
src/headset/webvr.c
View File

@ -8,7 +8,6 @@
#include <stdbool.h>
typedef struct {
bool initialized;
void (*renderCallback)(void*);
vec_controller_t controllers;
Canvas* canvas;
@ -49,7 +48,6 @@ static void onRequestAnimationFrame(void* userdata) {
}
static bool webvrInit(float offset) {
if (state.initialized) return true;
if (!emscripten_vr_is_present()) return false;
vec_init(&state.controllers);
emscripten_vr_init();
@ -58,7 +56,6 @@ static bool webvrInit(float offset) {
}
static void webvrDestroy() {
if (!state.initialized) return;
Controller* controller;
int i;
vec_foreach(&state.controllers, controller, i) {