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

lovr.headset.newModel;

This commit is contained in:
bjorn 2019-04-03 13:28:41 +09:00
parent cb79973b98
commit b95280006a
6 changed files with 77 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/api/headset.c
View File

@ -2,13 +2,10 @@
#include "api/headset.h"
#include "api/math.h"
#include "headset/headset.h"
<<<<<<< HEAD
#include "lib/maf.h"
#include "lib/map/map.h"
=======
#include "lib/math.h"
>>>>>>> Controller polyfill; rm Controller pose functions; OpenVR paths;
#include "data/modelData.h"
#include "graphics/model.h"
#include "graphics/texture.h"
#include "lib/math.h"
#if defined(EMSCRIPTEN) || defined(LOVR_USE_OCULUS_MOBILE)
#define LOVR_HEADSET_HELPER_USES_REGISTRY
@ -370,6 +367,27 @@ int l_lovrHeadsetVibrate(lua_State* L) {
return 1;
}
int l_lovrHeadsetNewModel(lua_State* L) {
Path path = luax_optpath(L, 1, "head");
ModelData* modelData = NULL;
FOREACH_TRACKING_DRIVER(driver) {
if ((modelData = driver->newModelData(path)) != NULL) {
break;
}
}
if (modelData) {
Model* model = lovrModelCreate(modelData);
luax_pushobject(L, model);
lovrRelease(ModelData, modelData);
lovrRelease(Model, model);
return 1;
}
return 0;
}
static int l_lovrHeadsetGetControllers(lua_State* L) {
uint8_t count;
Controller** controllers = lovrHeadsetDriver->getControllers(&count);
@ -447,6 +465,7 @@ static const luaL_Reg lovrHeadset[] = {
{ "getAngularVelocity", l_lovrHeadsetGetAngularVelocity },
{ "getAxis", l_lovrHeadsetGetAxis },
{ "vibrate", l_lovrHeadsetVibrate },
{ "newModel", l_lovrHeadsetNewModel },
{ "getControllers", l_lovrHeadsetGetControllers },
{ "getControllerCount", l_lovrHeadsetGetControllerCount },
{ "renderTo", l_lovrHeadsetRenderTo },

1
src/api/headset.h
View File

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

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

@ -93,16 +93,9 @@ static int l_lovrControllerVibrate(lua_State* L) {
static int l_lovrControllerNewModel(lua_State* L) {
Controller* controller = luax_checktype(L, 1, Controller);
ModelData* modelData = lovrHeadsetDriver->controllerNewModelData(controller);
if (modelData) {
Model* model = lovrModelCreate(modelData);
luax_pushobject(L, model);
lovrRelease(ModelData, modelData);
lovrRelease(Model, model);
} else {
lua_pushnil(L);
}
return 1;
luax_pushpath(L, controller->path);
lua_replace(L, 1);
return l_lovrHeadsetNewModel(L);
}
const luaL_Reg lovrController[] = {

10
src/headset/desktop.c
View File

@ -158,6 +158,10 @@ static bool desktopVibrate(Path path, float strength, float duration, float freq
return false;
}
static ModelData* desktopNewModelData(Path path) {
return NULL;
}
static Controller** desktopGetControllers(uint8_t* count) {
*count = state.controllers.length;
return state.controllers.data;
@ -179,10 +183,6 @@ static bool desktopControllerIsTouched(Controller* controller, ControllerButton
return false;
}
static ModelData* desktopControllerNewModelData(Controller* controller) {
return NULL;
}
static void desktopRenderTo(void (*callback)(void*), void* userdata) {
uint32_t width, height;
desktopGetDisplayDimensions(&width, &height);
@ -276,12 +276,12 @@ HeadsetInterface lovrHeadsetDesktopDriver = {
.getAngularVelocity = desktopGetAngularVelocity,
.getAxis = desktopGetAxis,
.vibrate = desktopVibrate,
.newModelData = desktopNewModelData,
.getControllers = desktopGetControllers,
.controllerIsConnected = desktopControllerIsConnected,
.controllerGetHand = desktopControllerGetHand,
.controllerIsDown = desktopControllerIsDown,
.controllerIsTouched = desktopControllerIsTouched,
.controllerNewModelData = desktopControllerNewModelData,
.renderTo = desktopRenderTo,
.update = desktopUpdate
};

2
src/headset/headset.h
View File

@ -114,12 +114,12 @@ typedef struct HeadsetInterface {
bool (*getAngularVelocity)(Path path, float* vx, float* vy, float* vz);
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);
ControllerHand (*controllerGetHand)(Controller* controller);
bool (*controllerIsDown)(Controller* controller, ControllerButton button);
bool (*controllerIsTouched)(Controller* controller, ControllerButton button);
struct ModelData* (*controllerNewModelData)(Controller* controller);
void (*renderTo)(void (*callback)(void*), void* userdata);
struct Texture* (*getMirrorTexture)(void);
void (*update)(float dt);

85
src/headset/openvr.c
View File

@ -377,62 +377,30 @@ static bool openvrVibrate(Path path, float strength, float duration, float frequ
return true;
}
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 ControllerHand openvrControllerGetHand(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 bool openvrControllerIsDown(Controller* controller, ControllerButton button) {
VRControllerState_t input;
state.system->GetControllerState(controller->id, &input, sizeof(input));
ControllerHand hand = openvrControllerGetHand(controller);
return getButtonState(input.ulButtonPressed, button, hand);
}
static bool openvrControllerIsTouched(Controller* controller, ControllerButton button) {
VRControllerState_t input;
state.system->GetControllerState(controller->id, &input, sizeof(input));
ControllerHand hand = openvrControllerGetHand(controller);
return getButtonState(input.ulButtonTouched, button, hand);
}
static ModelData* openvrControllerNewModelData(Controller* controller) {
if (!controller) return NULL;
int id = controller->id;
static ModelData* openvrNewModelData(Path path) {
TrackedDeviceIndex_t deviceIndex = getDeviceIndexForPath(path);
if (deviceIndex == INVALID_INDEX) return false;
// Get model name
char renderModelName[1024];
ETrackedDeviceProperty renderModelNameProperty = ETrackedDeviceProperty_Prop_RenderModelName_String;
state.system->GetStringTrackedDeviceProperty(controller->id, renderModelNameProperty, renderModelName, 1024, NULL);
state.system->GetStringTrackedDeviceProperty(deviceIndex, renderModelNameProperty, renderModelName, 1024, NULL);
// Load model
if (!state.deviceModels[id]) {
while (state.renderModels->LoadRenderModel_Async(renderModelName, &state.deviceModels[id]) == EVRRenderModelError_VRRenderModelError_Loading) {
if (!state.deviceModels[deviceIndex]) {
while (state.renderModels->LoadRenderModel_Async(renderModelName, &state.deviceModels[deviceIndex]) == EVRRenderModelError_VRRenderModelError_Loading) {
lovrSleep(.001);
}
}
// Load texture
if (!state.deviceTextures[id]) {
while (state.renderModels->LoadTexture_Async(state.deviceModels[id]->diffuseTextureId, &state.deviceTextures[id]) == EVRRenderModelError_VRRenderModelError_Loading) {
if (!state.deviceTextures[deviceIndex]) {
while (state.renderModels->LoadTexture_Async(state.deviceModels[deviceIndex]->diffuseTextureId, &state.deviceTextures[deviceIndex]) == EVRRenderModelError_VRRenderModelError_Loading) {
lovrSleep(.001);
}
}
RenderModel_t* vrModel = state.deviceModels[id];
RenderModel_t* vrModel = state.deviceModels[deviceIndex];
ModelData* model = lovrAlloc(ModelData);
size_t vertexSize = sizeof(RenderModel_Vertex_t);
@ -488,7 +456,7 @@ static ModelData* openvrControllerNewModelData(Controller* controller) {
.components = 1
};
RenderModel_TextureMap_t* vrTexture = state.deviceTextures[id];
RenderModel_TextureMap_t* vrTexture = state.deviceTextures[deviceIndex];
model->textures[0] = lovrTextureDataCreate(vrTexture->unWidth, vrTexture->unHeight, 0, FORMAT_RGBA);
memcpy(model->textures[0]->blob.data, vrTexture->rubTextureMapData, vrTexture->unWidth * vrTexture->unHeight * 4);
@ -518,6 +486,37 @@ static ModelData* openvrControllerNewModelData(Controller* controller) {
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 ControllerHand openvrControllerGetHand(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 bool openvrControllerIsDown(Controller* controller, ControllerButton button) {
VRControllerState_t input;
state.system->GetControllerState(controller->id, &input, sizeof(input));
ControllerHand hand = openvrControllerGetHand(controller);
return getButtonState(input.ulButtonPressed, button, hand);
}
static bool openvrControllerIsTouched(Controller* controller, ControllerButton button) {
VRControllerState_t input;
state.system->GetControllerState(controller->id, &input, sizeof(input));
ControllerHand hand = openvrControllerGetHand(controller);
return getButtonState(input.ulButtonTouched, button, hand);
}
static void openvrRenderTo(void (*callback)(void*), void* userdata) {
if (!state.canvas) {
uint32_t width, height;
@ -645,12 +644,12 @@ HeadsetInterface lovrHeadsetOpenVRDriver = {
.getAngularVelocity = openvrGetAngularVelocity,
.getAxis = openvrGetAxis,
.vibrate = openvrVibrate,
.newModelData = openvrNewModelData,
.getControllers = openvrGetControllers,
.controllerIsConnected = openvrControllerIsConnected,
.controllerGetHand = openvrControllerGetHand,
.controllerIsDown = openvrControllerIsDown,
.controllerIsTouched = openvrControllerIsTouched,
.controllerNewModelData = openvrControllerNewModelData,
.renderTo = openvrRenderTo,
.getMirrorTexture = openvrGetMirrorTexture,
.update = openvrUpdate