SteamFrame/OpenVR-AdvancedSettings-frame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor out duplicate PTT logic into a shared controller.

Browse Source
This commit is contained in:
Mel Klimushyn
2017-01-29 00:55:16 -08:00
parent 39f81f39ab
commit 6271f230df
10 changed files with 805 additions and 1089 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/tabcontrollers/MoveCenterTabController.cpp
+11 -222
View File
@@ -137,70 +137,20 @@ void MoveCenterTabController::setAdjustChaperone(bool value, bool notify) {
}
}
bool MoveCenterTabController::pttEnabled() const {
return m_pttEnabled;
void MoveCenterTabController::onPttStart() {
m_toggleOffsetY = m_offsetY;
parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, 1, -m_toggleOffsetY, m_adjustChaperone);
}
void MoveCenterTabController::setPttEnabled(bool value, bool notify, bool save) {
std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
if (value != m_pttEnabled) {
m_pttEnabled = value;
if (notify) {
emit pttEnabledChanged(value);
}
if (save) {
savePttConfig();
}
}
void MoveCenterTabController::onPttStop() {
parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, 1, m_toggleOffsetY, m_adjustChaperone);
}
void MoveCenterTabController::offsetYToggle(bool enabled) {
float delta;
if (enabled) {
m_toggleOffsetY = m_offsetY;
delta = -m_toggleOffsetY;
} else {
delta = m_toggleOffsetY;
}
parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, 1, delta, m_adjustChaperone);
}
bool MoveCenterTabController::pttActive() const {
return m_pttActive;
}
bool MoveCenterTabController::pttLeftControllerEnabled() const {
return m_pttLeftControllerEnabled;
}
void MoveCenterTabController::setPttLeftControllerEnabled(bool value, bool notify, bool save) {
std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
if (value != m_pttLeftControllerEnabled) {
m_pttLeftControllerEnabled = value;
if (notify) {
emit pttLeftControllerEnabledChanged(value);
}
if (save) {
savePttConfig();
}
}
}
bool MoveCenterTabController::pttRightControllerEnabled() const {
return m_pttRightControllerEnabled;
}
void MoveCenterTabController::setPttRightControllerEnabled(bool value, bool notify, bool save) {
std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
if (value != m_pttRightControllerEnabled) {
m_pttRightControllerEnabled = value;
if (notify) {
emit pttRightControllerEnabledChanged(value);
}
if (save) {
savePttConfig();
}
void MoveCenterTabController::onPttDisabled() {
if (pttActive()) {
stopPtt();
}
m_toggleOffsetY = 0;
}
void MoveCenterTabController::modOffsetX(float value, bool notify) {
@@ -244,6 +194,7 @@ void MoveCenterTabController::modOffsetZ(float value, bool notify) {
}
void MoveCenterTabController::reset() {
std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
vr::VRChaperoneSetup()->RevertWorkingCopy();
parent->RotateUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, -m_rotation * 2 * M_PI / 360.0, m_adjustChaperone, false);
parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, 0, -m_offsetX, m_adjustChaperone, false);
@@ -271,170 +222,8 @@ void MoveCenterTabController::eventLoopTick(vr::ETrackingUniverseOrigin universe
} else {
settingsUpdateCounter++;
}
static auto handleControllerState = [](const vr::VRControllerState_t& state, PttControllerConfig* config) -> bool {
if (state.ulButtonPressed & config->digitalButtonMask) {
return true;
}
if (config->triggerMode) {
if (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_SteamVR_Trigger)
|| state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_SteamVR_Trigger)) {
return true;
}
}
if (config->touchpadMode) {
if (((config->touchpadMode & 1) && (state.ulButtonTouched & vr::ButtonMaskFromId(vr::k_EButton_SteamVR_Touchpad)))
|| ((config->touchpadMode & 2) && (state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_SteamVR_Touchpad)))) {
if (config->touchpadAreas == (PAD_AREA_LEFT + PAD_AREA_TOP + PAD_AREA_RIGHT + PAD_AREA_BOTTOM)) {
return true;
} else {
float x = state.rAxis[0].x;
float y = state.rAxis[0].y;
if (std::abs(x) >= 0.2 || std::abs(y) >= 0.2) { // deadzone in the middle
if (x < 0 && std::abs(y) < -x && (config->touchpadAreas & PAD_AREA_LEFT)) {
return true;
} else if (y > 0 && std::abs(x) < y && (config->touchpadAreas & PAD_AREA_TOP)) {
return true;
} else if (x > 0 && std::abs(y) < x && (config->touchpadAreas & PAD_AREA_RIGHT)) {
return true;
} else if (y < 0 && std::abs(x) < -y && (config->touchpadAreas & PAD_AREA_BOTTOM)) {
return true;
}
}
}
}
}
return false;
};
if (m_pttEnabled) {
bool newState = false;
if (m_pttLeftControllerEnabled) {
auto leftId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_LeftHand);
if (leftId != vr::k_unTrackedDeviceIndexInvalid) {
vr::VRControllerState_t state;
if (vr::VRSystem()->GetControllerState(leftId, &state, sizeof(vr::VRControllerState_t))) {
newState |= handleControllerState(state, m_pttControllerConfigs);
}
}
}
if (m_pttRightControllerEnabled) {
auto rightId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_RightHand);
if (rightId != vr::k_unTrackedDeviceIndexInvalid) {
vr::VRControllerState_t state;
if (vr::VRSystem()->GetControllerState(rightId, &state, sizeof(vr::VRControllerState_t))) {
newState |= handleControllerState(state, m_pttControllerConfigs + 1);
}
}
}
if (newState && !m_pttActive) {
m_pttActive = true;
offsetYToggle(true);
emit pttActiveChanged(m_pttActive);
} else if (!newState && m_pttActive) {
m_pttActive = false;
offsetYToggle(false);
emit pttActiveChanged(m_pttActive);
}
}
checkPttStatus();
eventLoopMutex.unlock();
}
void MoveCenterTabController::setPttControllerConfig(unsigned controller, QVariantList buttons, unsigned triggerMode, unsigned padMode, unsigned padAreas) {
std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
if (controller < 2) {
uint64_t buttonMask = 0;
for (auto b : buttons) {
buttonMask |= vr::ButtonMaskFromId((vr::EVRButtonId)b.toInt());
}
m_pttControllerConfigs[controller].digitalButtons = buttons;
m_pttControllerConfigs[controller].digitalButtonMask = buttonMask;
m_pttControllerConfigs[controller].triggerMode = triggerMode;
m_pttControllerConfigs[controller].touchpadMode = padMode;
m_pttControllerConfigs[controller].touchpadAreas = padAreas;
savePttConfig();
}
}
void MoveCenterTabController::reloadPttConfig() {
std::lock_guard<std::recursive_mutex> lock(eventLoopMutex);
auto settings = OverlayController::appSettings();
settings->beginGroup("playspaceSettings");
setPttEnabled(settings->value("pttEnabled", false).toBool(), true, false);
setPttLeftControllerEnabled(settings->value("pttLeftControllerEnabled", false).toBool(), true, false);
setPttRightControllerEnabled(settings->value("pttRightControllerEnabled", false).toBool(), true, false);
m_pttControllerConfigs[0].digitalButtons = settings->value("pttDigitalButtons_0").toList();
uint64_t buttonMask = 0;
for (auto b : m_pttControllerConfigs[0].digitalButtons) {
buttonMask |= vr::ButtonMaskFromId((vr::EVRButtonId)b.toInt());
}
m_pttControllerConfigs[0].digitalButtonMask = buttonMask;
m_pttControllerConfigs[0].triggerMode = settings->value("pttTriggerMode_0", 0).toUInt();
m_pttControllerConfigs[0].touchpadMode = settings->value("pttTouchpadMode_0", 0).toUInt();
m_pttControllerConfigs[0].touchpadAreas = settings->value("pttTouchPadAreas_0", 0).toUInt();
m_pttControllerConfigs[1].digitalButtons = settings->value("pttDigitalButtons_1").toList();
buttonMask = 0;
for (auto b : m_pttControllerConfigs[0].digitalButtons) {
buttonMask |= vr::ButtonMaskFromId((vr::EVRButtonId)b.toInt());
}
m_pttControllerConfigs[1].digitalButtonMask = buttonMask;
m_pttControllerConfigs[1].triggerMode = settings->value("pttTriggerMode_1", 0).toUInt();
m_pttControllerConfigs[1].touchpadMode = settings->value("pttTouchpadMode_1", 0).toUInt();
m_pttControllerConfigs[1].touchpadAreas = settings->value("pttTouchPadAreas_1", 0).toUInt();
settings->endGroup();
}
void MoveCenterTabController::savePttConfig() {
auto settings = OverlayController::appSettings();
settings->beginGroup("playspaceSettings");
settings->setValue("pttEnabled", pttEnabled());
settings->setValue("pttLeftControllerEnabled", pttLeftControllerEnabled());
settings->setValue("pttRightControllerEnabled", pttRightControllerEnabled());
settings->setValue("pttDigitalButtons_0", m_pttControllerConfigs[0].digitalButtons);
settings->setValue("pttTriggerMode_0", m_pttControllerConfigs[0].triggerMode);
settings->setValue("pttTouchpadMode_0", m_pttControllerConfigs[0].touchpadMode);
settings->setValue("pttTouchPadAreas_0", m_pttControllerConfigs[0].touchpadAreas);
settings->setValue("pttDigitalButtons_1", m_pttControllerConfigs[1].digitalButtons);
settings->setValue("pttTriggerMode_1", m_pttControllerConfigs[1].triggerMode);
settings->setValue("pttTouchpadMode_1", m_pttControllerConfigs[1].touchpadMode);
settings->setValue("pttTouchPadAreas_1", m_pttControllerConfigs[1].touchpadAreas);
settings->endGroup();
}
QVariantList MoveCenterTabController::pttDigitalButtons(unsigned controller) {
if (controller < 2) {
return m_pttControllerConfigs[controller].digitalButtons;
}
return QVariantList();
}
unsigned long MoveCenterTabController::pttDigitalButtonMask(unsigned controller) {
if (controller < 2) {
return m_pttControllerConfigs[controller].digitalButtonMask;
}
return 0;
}
unsigned MoveCenterTabController::pttTouchpadMode(unsigned controller) {
if (controller < 2) {
return m_pttControllerConfigs[controller].touchpadMode;
}
return 0;
}
unsigned MoveCenterTabController::pttTriggerMode(unsigned controller) {
if (controller < 2) {
return m_pttControllerConfigs[controller].triggerMode;
}
return 0;
}
unsigned MoveCenterTabController::pttTouchpadArea(unsigned controller) {
if (controller < 2) {
return m_pttControllerConfigs[controller].touchpadAreas;
}
return 0;
}
} // namespace advconfig